#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/GLCanvas3D.hpp>

Collaboration diagram for Slic3r::GUI::GLCanvas3D:

Classes
class	LayersEditing
struct	Mouse
struct	SlaCap
class	RenderStats
class	Labels
class	CenterOfMass
class	Tooltip
class	Slope
class	RenderTimer
class	ToolbarHighlighterTimer
class	GizmoHighlighterTimer
struct	ArrangeSettings
struct	OrientSettings
struct	SectionView
struct	KeyDown
struct	SelectionEdit
class	SequentialPrintClearance
struct	ToolbarHighlighter
struct	GizmoHighlighter
class	WipeTowerInfo

Public Types
enum	ECursorType : unsigned char { Standard , Cross }
enum	ECanvasType { CanvasView3D = 0 , CanvasPreview = 1 , CanvasAssembleView = 2 }
enum class	MouseButton { None , Left , Middle , Right }
enum class	MouseAction { None , Pan , Rotation }

Public Member Functions
int	GetHoverId ()
OrientSettings &	get_orient_settings ()
void	load_arrange_settings ()
ArrangeSettings &	get_arrange_settings ()
	GLCanvas3D (wxGLCanvas *canvas, Bed3D &bed)
	~GLCanvas3D ()
bool	is_initialized () const
void	set_context (wxGLContext *context)
void	set_type (ECanvasType type)
void	set_studio_lighting (bool on)
ECanvasType	get_canvas_type ()
wxGLCanvas *	get_wxglcanvas ()
const wxGLCanvas *	get_wxglcanvas () const
bool	init ()
void	post_event (wxEvent &&event)
std::shared_ptr< SceneRaycasterItem >	add_raycaster_for_picking (SceneRaycaster::EType type, int id, const MeshRaycaster &raycaster, const Transform3d &trafo=Transform3d::Identity(), bool use_back_faces=false)
void	remove_raycasters_for_picking (SceneRaycaster::EType type, int id)
void	remove_raycasters_for_picking (SceneRaycaster::EType type)
std::vector< std::shared_ptr< SceneRaycasterItem > > *	get_raycasters_for_picking (SceneRaycaster::EType type)
void	set_raycaster_gizmos_on_top (bool value)
float	get_explosion_ratio ()
void	reset_explosion_ratio ()
void	on_change_color_mode (bool is_dark, bool reinit=true)
const bool	get_dark_mode_status ()
void	set_as_dirty ()
void	requires_check_outside_state ()
unsigned int	get_volumes_count () const
const GLVolumeCollection &	get_volumes () const
void	reset_volumes ()
ModelInstanceEPrintVolumeState	check_volumes_outside_state (ObjectFilamentResults *object_results=nullptr) const
void	check_volumes_outside_state (GLVolumeCollection &volumes) const
bool	is_all_plates_selected ()
const float	get_scale () const
GCodeViewer &	get_gcode_viewer ()
void	init_gcode_viewer (ConfigOptionMode mode, Slic3r::PresetBundle *preset_bundle)
void	reset_gcode_toolpaths ()
const GCodeViewer::SequentialView &	get_gcode_sequential_view () const
void	update_gcode_sequential_view_current (unsigned int first, unsigned int last)
const libvgcode::Interval &	get_gcode_view_full_range () const
const libvgcode::Interval &	get_gcode_view_enabled_range () const
const libvgcode::Interval &	get_gcode_view_visible_range () const
const libvgcode::PathVertex &	get_gcode_vertex_at (size_t id) const
void	toggle_selected_volume_visibility (bool selected_visible)
void	toggle_sla_auxiliaries_visibility (bool visible, const ModelObject *mo=nullptr, int instance_idx=-1)
void	toggle_model_objects_visibility (bool visible, const ModelObject mo=nullptr, int instance_idx=-1, const ModelVolume mv=nullptr)
void	update_instance_printable_state_for_object (size_t obj_idx)
void	update_instance_printable_state_for_objects (const std::vector< size_t > &object_idxs)
void	set_config (const DynamicPrintConfig *config)
void	set_process (BackgroundSlicingProcess *process)
void	set_model (Model *model)
const Model *	get_model () const
const Selection &	get_selection () const
Selection &	get_selection ()
const GLGizmosManager &	get_gizmos_manager () const
GLGizmosManager &	get_gizmos_manager ()
void	bed_shape_changed ()
void	plates_count_changed ()
Camera &	get_camera ()
void	set_clipping_plane (unsigned int id, const ClippingPlane &plane)
void	reset_clipping_planes_cache ()
void	set_use_clipping_planes (bool use)
bool	get_use_clipping_planes () const
const std::array< ClippingPlane, 2 > &	get_clipping_planes () const
void	set_use_color_clip_plane (bool use)
void	set_color_clip_plane (const Vec3d &cp_normal, double offset)
void	set_color_clip_plane_colors (const std::array< ColorRGBA, 2 > &colors)
bool	is_section_view_active () const
double	get_section_view_ratio () const
const Vec3d &	get_section_view_normal () const
void	set_section_view_ratio (double ratio)
void	toggle_section_view ()
void	align_section_view_to_camera ()
void	share_section_view (const GLCanvas3D &owner)
void	toggle_world_axes_visibility (bool force_show=false)
void	refresh_camera_scene_box ()
void	set_color_by (const std::string &value)
BoundingBoxf3	volumes_bounding_box (bool current_plate_only=false) const
BoundingBoxf3	scene_bounding_box () const
BoundingBoxf3	plate_scene_bounding_box (int plate_idx) const
bool	is_layers_editing_enabled () const
bool	is_layers_editing_allowed () const
void	reset_layer_height_profile ()
void	adaptive_layer_height_profile (float quality_factor)
void	smooth_layer_height_profile (const HeightProfileSmoothingParams &smoothing_params)
bool	is_reload_delayed () const
void	enable_layers_editing (bool enable)
void	enable_picking (bool enable)
void	enable_moving (bool enable)
void	enable_gizmos (bool enable)
void	enable_selection (bool enable)
void	enable_main_toolbar (bool enable)
void	_update_select_plate_toolbar_stats_item (bool force_selected=false)
void	reset_select_plate_toolbar_selection ()
void	enable_select_plate_toolbar (bool enable)
void	enable_assemble_view_toolbar (bool enable)
void	enable_return_toolbar (bool enable)
void	enable_separator_toolbar (bool enable)
void	enable_collapse_toolbar (bool enable)
void	set_collapse_toolbar (GLToolbar *toolbar, std::function< CollapseSide()> side)
void	enable_plate_chrome (bool enable)
void	set_design_canvas (bool b)
void	set_show_bed (bool b)
bool	get_show_bed () const
void	enable_sinking_contours (bool enable)
void	enable_dynamic_background (bool enable)
void	enable_labels (bool enable)
void	enable_slope (bool enable)
void	allow_multisample (bool allow)
void	zoom_to_bed ()
void	zoom_to_volumes ()
void	zoom_to_selection ()
void	zoom_to_gcode ()
void	zoom_to_plate (int plate_idx=-1)
void	select_view (const std::string &direction)
void	select_plate ()
int	get_main_toolbar_offset () const
int	get_main_toolbar_height () const
int	get_main_toolbar_width () const
float	get_assemble_view_toolbar_width () const
float	get_assemble_view_toolbar_height () const
float	get_assembly_paint_toolbar_width () const
float	get_separator_toolbar_width () const
float	get_separator_toolbar_height () const
bool	is_collapse_toolbar_on_left () const
float	get_collapse_toolbar_width () const
float	get_collapse_toolbar_height () const
float	get_canvas_toolbar_right () const
void	update_volumes_colors_by_extruder ()
bool	is_dragging () const
bool	has_mouse_capture () const
void	render (bool only_init=false)
bool	is_rendering_enabled ()
void	enable_render (bool enabled)
void	render_thumbnail (ThumbnailData &thumbnail_data, unsigned int w, unsigned int h, const ThumbnailsParams &thumbnail_params, Camera::EType camera_type, Camera::ViewAngleType camera_view_angle_type=Camera::ViewAngleType::Iso, bool for_picking=false, bool ban_light=false)
void	render_thumbnail (ThumbnailData &thumbnail_data, unsigned int w, unsigned int h, const ThumbnailsParams &thumbnail_params, ModelObjectPtrs &model_objects, const GLVolumeCollection &volumes, Camera::EType camera_type, Camera::ViewAngleType camera_view_angle_type=Camera::ViewAngleType::Iso, bool for_picking=false, bool ban_light=false)
void	render_thumbnail (ThumbnailData &thumbnail_data, std::vector< ColorRGBA > &extruder_colors, unsigned int w, unsigned int h, const ThumbnailsParams &thumbnail_params, ModelObjectPtrs &model_objects, const GLVolumeCollection &volumes, Camera::EType camera_type, Camera::ViewAngleType camera_view_angle_type=Camera::ViewAngleType::Iso, bool for_picking=false, bool ban_light=false)
void	select_curr_plate_all ()
void	select_object_from_idx (std::vector< int > &object_idxs)
void	remove_curr_plate_all ()
void	select_all ()
void	deselect_all ()
void	exit_gizmo ()
void	set_selected_visible (bool visible)
void	delete_selected ()
void	ensure_on_bed (unsigned int object_idx, bool allow_negative_z)
std::vector< double >	get_gcode_layers_zs () const
std::vector< float >	get_gcode_layers_times () const
const std::vector< float > &	get_gcode_layers_times_cache () const
void	reset_gcode_layers_times_cache ()
void	set_volumes_z_range (const std::array< double, 2 > &range)
size_t	get_gcode_extruders_count ()
std::vector< int >	load_object (const ModelObject &model_object, int obj_idx, std::vector< int > instance_idxs)
std::vector< int >	load_object (const Model &model, int obj_idx)
void	mirror_selection (Axis axis)
void	reload_scene (bool refresh_immediately, bool force_full_scene_refresh=false)
void	set_shell_transparence (float alpha=0.2f)
void	load_shells (const Print &print, bool force_previewing=false)
void	reset_shells ()
void	set_shells_on_previewing (bool is_preview)
void	load_gcode_preview (const GCodeProcessorResult &gcode_result, const std::vector< std::string > &str_tool_colors, const std::vector< std::string > &str_color_print_colors, bool only_gcode)
void	set_gcode_view_type (libvgcode::EViewType type)
libvgcode::EViewType	get_gcode_view_type () const
void	load_sla_preview ()
void	bind_event_handlers ()
void	unbind_event_handlers ()
void	on_size (wxSizeEvent &evt)
void	on_idle (wxIdleEvent &evt)
void	on_char (wxKeyEvent &evt)
void	on_key (wxKeyEvent &evt)
void	release_held_modifiers ()
bool	handle_shortcut (const KeyChord &chord)
void	apply_selection_move (bool slow, bool camera_space)
void	apply_selection_rotate (double angle_z_rad)
void	finish_selection_edit ()
void	update_shortcut_tooltips ()
void	on_mouse_wheel (wxMouseEvent &evt)
void	on_timer (wxTimerEvent &evt)
void	on_render_timer (wxTimerEvent &evt)
void	on_set_color_timer (wxTimerEvent &evt)
void	on_fps_overlay_timer (wxTimerEvent &evt)
void	on_mouse (wxMouseEvent &evt)
void	on_gesture (wxGestureEvent &evt)
void	on_paint (wxPaintEvent &evt)
void	on_set_focus (wxFocusEvent &evt)
void	force_set_focus ()
bool	clicked_button_matches_action (const wxMouseEvent &evt, MouseAction action, const std::map< MouseButton, MouseAction > &mappings) const
bool	is_camera_rotate (const wxMouseEvent &evt, const std::map< MouseButton, MouseAction > &mappings) const
bool	is_camera_pan (const wxMouseEvent &evt, const std::map< MouseButton, MouseAction > &mappings) const
Size	get_canvas_size () const
Vec2d	get_local_mouse_position () const
void	set_popup_menu_position (const Vec2d &position)
const std::optional< Vec2d > &	get_popup_menu_position () const
void	clear_popup_menu_position ()
void	set_tooltip (const std::string &tooltip)
void	do_move (const std::string &snapshot_type, bool force_volume_move=false)
void	do_rotate (const std::string &snapshot_type)
void	do_scale (const std::string &snapshot_type)
void	do_center ()
void	do_drop ()
void	do_center_plate (const int plate_idx)
void	do_mirror (const std::string &snapshot_type)
void	update_gizmos_on_off_state ()
void	reset_all_gizmos ()
void	handle_sidebar_focus_event (const std::string &opt_key, bool focus_on)
void	handle_layers_data_focus_event (const t_layer_height_range range, const EditorType type)
void	update_ui_from_settings ()
int	get_move_volume_id () const
int	get_first_hover_volume_idx () const
int	get_hover_ghost_head () const
int	get_hover_ghost_plate () const
void	set_selected_extruder (int extruder)
WipeTowerInfo	get_wipe_tower_info (int plate_idx) const
Linef3	mouse_ray (const Point &mouse_pos)
void	set_mouse_as_dragging ()
bool	is_mouse_dragging () const
bool	is_mouse_left_up_ignored () const
double	get_size_proportional_to_max_bed_size (double factor) const
std::vector< Vec2f >	get_empty_cells (const Vec2f start_point, const Vec2f step={10, 10})
Vec2f	get_nearest_empty_cell (const Vec2f start_point, const Vec2f step={10, 10})
void	set_cursor (ECursorType type)
void	msw_rescale ()
void	request_extra_frame ()
void	schedule_extra_frame (int milliseconds)
void	set_benchmarking (bool benchmarking)
FrameProfiler &	get_frame_profiler ()
int	get_main_toolbar_item_id (const std::string &name) const
void	force_main_toolbar_left_action (int item_id)
void	force_main_toolbar_right_action (int item_id)
bool	has_toolpaths_to_export () const
void	export_toolpaths_to_obj (const char *filename) const
void	mouse_up_cleanup ()
bool	are_labels_shown () const
void	show_labels (bool show)
bool	is_overhang_shown () const
void	show_overhang (bool show)
bool	is_using_slope () const
void	use_slope (bool use)
void	set_slope_normal_angle (float angle_in_deg)
void	highlight_toolbar_item (const std::string &item_name)
void	highlight_gizmo (const std::string &gizmo_name)
void	reset_sequential_print_clearance ()
void	set_sequential_print_clearance_visible (bool visible)
void	set_sequential_print_clearance_render_fill (bool render_fill)
void	set_sequential_print_clearance_polygons (const Polygons &polygons, const std::vector< std::pair< Polygon, float > > &height_polygons)
bool	can_sequential_clearance_show_in_gizmo ()
void	update_sequential_clearance ()
void	update_compacted_wipe_tower_clearance ()
const Print *	fff_print () const
const SLAPrint *	sla_print () const
void	reset_old_size ()
bool	is_object_sinking (int object_idx) const
void	apply_retina_scale (Vec2d &screen_coordinate) const
void	_perform_layer_editing_action (wxMouseEvent *evt=nullptr)
Vec3d	_mouse_to_3d (const Point &mouse_pos, float *z=nullptr)
bool	make_current_for_postinit ()
void	set_imgui_scaling ()

Static Public Member Functions
static bool	is_frame_in_progress ()
static void	render_thumbnail_internal (ThumbnailData &thumbnail_data, const ThumbnailsParams &thumbnail_params, PartPlateList &partplate_list, ModelObjectPtrs &model_objects, const GLVolumeCollection &volumes, std::vector< ColorRGBA > &extruder_colors, GLShaderProgram *shader, Camera::EType camera_type, Camera::ViewAngleType camera_view_angle_type=Camera::ViewAngleType::Iso, bool for_picking=false, bool ban_light=false)
static void	render_thumbnail_framebuffer (ThumbnailData &thumbnail_data, unsigned int w, unsigned int h, const ThumbnailsParams &thumbnail_params, PartPlateList &partplate_list, ModelObjectPtrs &model_objects, const GLVolumeCollection &volumes, std::vector< ColorRGBA > &extruder_colors, GLShaderProgram *shader, Camera::EType camera_type, Camera::ViewAngleType camera_view_angle_type=Camera::ViewAngleType::Iso, bool for_picking=false, bool ban_light=false)
static void	render_thumbnail_framebuffer_ext (ThumbnailData &thumbnail_data, unsigned int w, unsigned int h, const ThumbnailsParams &thumbnail_params, PartPlateList &partplate_list, ModelObjectPtrs &model_objects, const GLVolumeCollection &volumes, std::vector< ColorRGBA > &extruder_colors, GLShaderProgram *shader, Camera::EType camera_type, Camera::ViewAngleType camera_view_angle_type=Camera::ViewAngleType::Iso, bool for_picking=false, bool ban_light=false)
static void	render_thumbnail_legacy (ThumbnailData &thumbnail_data, unsigned int w, unsigned int h, const ThumbnailsParams &thumbnail_params, PartPlateList &partplate_list, ModelObjectPtrs &model_objects, const GLVolumeCollection &volumes, std::vector< ColorRGBA > &extruder_colors, GLShaderProgram *shader, Camera::EType camera_type, Camera::ViewAngleType camera_view_angle_type=Camera::ViewAngleType::Iso, bool for_picking=false, bool ban_light=false)
static int64_t	timestamp_now ()

Public Attributes
SequentialPrintClearance	m_sequential_print_clearance
bool	m_sequential_print_clearance_first_displacement { true }
struct Slic3r::GUI::GLCanvas3D::ToolbarHighlighter	m_toolbar_highlighter
struct Slic3r::GUI::GLCanvas3D::GizmoHighlighter	m_gizmo_highlighter
GLModel	m_background
unsigned int	m_fxaa_texture_id { 0 }
std::array< unsigned int, 2 >	m_fxaa_texture_size { 0, 0 }
unsigned int	m_ssao_color_texture_id { 0 }
unsigned int	m_ssao_depth_texture_id { 0 }
std::array< unsigned int, 2 >	m_ssao_texture_size { { 0, 0 } }
SceneCache	m_scene_cache
std::optional< size_t >	m_presented_signature
GLModel	m_plate_shadow_mask
std::string	m_plate_shadow_mask_key
unsigned int	m_shadow_map_fbo { 0 }
unsigned int	m_shadow_map_texture_id { 0 }
unsigned int	m_shadow_map_size { 0 }
Transform3d	m_shadow_light_vp { Transform3d::Identity() }
bool	m_shadow_map_valid { false }
size_t	m_shadow_map_key { 0 }
std::array< float, 4 >	m_shadow_plate_bounds { { 0.0f, 0.0f, 0.0f, 0.0f } }
std::optional< Vec2d >	m_popup_menu_positon

Private Types
enum class	EWarning { ObjectOutside , ToolpathOutside , SlaSupportsOutside , SomethingNotShown , ObjectClashed , ObjectLimited , GCodeConflict , ToolHeightOutside , TPUPrintableError , FilamentPrintableError , LeftExtruderPrintableError , RightExtruderPrintableError , MultiExtruderPrintableError , MultiExtruderHeightOutside , FilamentUnPrintableOnFirstLayer , MixUsePLAAndPETG , PrimeTowerOutside , NozzleFilamentIncompatible , MixtureFilamentIncompatible , SingleExtruderMixedFilament , FlushingVolumeZero }
enum class	EShadowMode { Off , Static , Orbit }
enum class	ECameraNavigationType : unsigned char { Mouse , Gesture }

Private Member Functions
PrinterTechnology	current_printer_technology () const
bool	check_volumes_outside_state (GLVolumeCollection &volumes, ModelInstanceEPrintVolumeState *out_state, bool selection_only=true) const
bool	_is_shown_on_screen () const
void	_update_slice_error_status ()
void	_switch_toolbars_icon_filename ()
bool	_init_toolbars ()
bool	_init_main_toolbar ()
bool	_init_select_plate_toolbar ()
bool	_update_imgui_select_plate_toolbar ()
bool	_init_assemble_view_toolbar ()
bool	_init_return_toolbar ()
bool	_init_separator_toolbar ()
bool	_init_collapse_toolbar ()
GLToolbar &	collapse_toolbar () const
CollapseSide	collapse_side () const
bool	_set_current ()
bool	_set_shown_canvas_current ()
void	_resize (unsigned int w, unsigned int h)
BoundingBoxf3	_max_bounding_box (bool include_gizmos, bool include_bed_model, bool include_plates) const
void	_zoom_to_box (const BoundingBoxf3 &box, double margin_factor=DefaultCameraZoomToBoxMarginFactor)
void	_update_camera_zoom (double zoom)
void	_refresh_if_shown_on_screen (bool scene_dirty=true)
void	_picking_pass ()
void	_rectangular_selection_picking_pass ()
void	_picking_pass_imex_ghosts ()
bool	_is_fxaa_enabled () const
bool	_is_realistic_view_enabled () const
bool	_is_ssao_enabled () const
int	_get_effective_fps_cap () const
bool	_is_fps_overlay_enabled () const
bool	_is_render_timings_enabled () const
EShadowMode	_shadow_mode () const
std::optional< Vec3d >	_static_light_dir_eye () const
size_t	_shadow_casters_signature (bool toolpath_casters) const
bool	_is_scene_cache_enabled () const
bool	_is_scene_cacheable () const
bool	_is_frame_skipping_enabled () const
void	_render_fps_overlay (int fps) const
void	_render_fxaa_pass (unsigned int width, unsigned int height)
void	_render_ssao_pass (unsigned int width, unsigned int height)
void	_render_frame (bool scene_dirty, bool only_init=false)
void	_render_scene (const Camera &camera, const Size &cnv_size)
void	_set_overlay_as_dirty ()
SceneCache::Key	_scene_cache_key (const Camera &camera) const
bool	_can_reuse_cached_scene (const Camera &camera) const
void	_capture_scene_cache (const Camera &camera)
void	_render_background ()
void	_render_bed (const Transform3d &view_matrix, const Transform3d &projection_matrix, bool bottom, bool show_axes)
void	_render_shadows (const Transform3d &view_matrix, const Transform3d &projection_matrix)
void	_render_platelist (const Transform3d &view_matrix, const Transform3d &projection_matrix, bool bottom, bool only_current, bool only_body=false, int hover_id=-1, bool render_cali=false, bool show_grid=true)
bool	_hides_inactive_plates () const
bool	_update_inactive_plates_visibility ()
BoundingBoxf3	_current_plate_box () const
void	_render_cad_grid (const Transform3d &view_matrix, const Transform3d &projection_matrix)
void	_render_objects (GLVolumeCollection::ERenderType type, bool with_outline=true)
void	_render_imex_ghosts (bool xray_pass=false)
void	_render_imex_ghosts_xray ()
void	_render_imex_ghost_tooltip ()
void	_render_section_view_caps ()
void	_render_wireframe_overlay ()
bool	_is_below_plate_view_active () const
void	_render_below_plate_volumes ()
bool	_is_xray_view_active () const
void	_render_xray_volumes ()
void	_render_gcode (int canvas_width, int canvas_height)
void	_render_gcode_translucent (int canvas_width, int canvas_height)
bool	_bind_gcode_shadow_map (bool bind) const
void	_render_gcode_overlay (int canvas_width, int canvas_height)
void	_render_plane () const
void	_render_selection ()
void	_render_sequential_clearance ()
void	_check_and_update_toolbar_icon_scale ()
void	_render_overlays ()
void	_render_overlay_toolbars ()
size_t	_overlay_signature (const ImDrawData *draw_data) const
void	_render_style_editor ()
void	_render_volumes_for_picking (const Camera &camera) const
void	_render_current_gizmo () const
void	_render_gizmos_overlay ()
void	_render_main_toolbar ()
void	_render_imgui_select_plate_toolbar ()
void	_render_plate_switcher ()
void	_render_assemble_view_toolbar () const
void	_render_return_toolbar () const
void	_render_canvas_toolbar ()
void	_render_section_view_panel (const ImVec2 &bottom_left)
void	_render_separator_toolbar_right () const
void	_render_separator_toolbar_left () const
void	_render_collapse_toolbar () const
void	_render_paint_toolbar () const
float	_render_assembly_tooltip_button (ImGuiWrapper *imgui_wrapper) const
void	_render_assemble_control ()
void	_render_assemble_info () const
void	_render_sla_slices ()
void	_render_selection_sidebar_hints ()
bool	_render_orient_menu (float left, float right, float bottom, float top)
void	_render_arrange_menu (float left, float right, float bottom, float top)
void	_render_3d_navigator ()
void	_update_volumes_hover_state ()
Vec3d	_mouse_to_bed_3d (const Point &mouse_pos)
void	_on_section_view_changed ()
ClippingPlane	_get_section_view_plane () const
ClippingPlane	_get_volumes_clipping_plane () const
ClippingPlane	get_raycaster_clipping_plane () const
bool	is_bed_visible () const
std::optional< Vec3d >	get_camera_orbit_target (ECameraNavigationType navigation_type) const
Vec3d	get_camera_pan_anchor (Camera &camera, ECameraNavigationType navigation_type, const Vec2d &screen_position) const
void	_start_timer ()
void	_stop_timer ()
void	_load_sla_shells ()
void	_update_sla_shells_outside_state ()
void	_set_warning_notification_if_needed (EWarning warning)
BoundingBoxf3	_get_current_partplate_print_volume ()
void	_set_warning_notification (EWarning warning, bool state)
bool	is_flushing_matrix_error ()
bool	_is_any_volume_outside () const
void	_update_selection_from_hover ()
bool	_deactivate_collapse_toolbar_items ()
bool	_deactivate_arrange_menu ()
bool	_deactivate_orient_menu ()
bool	_deactivate_layersediting_menu ()
float	get_overlay_window_width ()

Static Private Member Functions
static void	update_render_colors ()
static void	load_render_colors ()

Private Attributes
bool	m_is_dark = false
wxGLCanvas *	m_canvas
wxGLContext *	m_context
SceneRaycaster	m_scene_raycaster
Bed3D &	m_bed
std::vector< std::pair< wxString, wxString > >	m_shortcuts_assembly_view
unsigned int	m_last_w
unsigned int	m_last_h
bool	m_in_render
wxTimer	m_timer
wxTimer	m_timer_set_color
wxTimer	m_fps_overlay_timer
bool	m_fps_overlay_tick { false }
LayersEditing	m_layers_editing
Mouse	m_mouse
std::optional< Vec3d >	m_gesture_pan_anchor
GLGizmosManager	m_gizmos
GLToolbar	m_main_toolbar
GLToolbar	m_separator_toolbar
IMToolbar	m_sel_plate_toolbar
std::vector< std::unique_ptr< IMToolbarItem > >	m_plate_switcher_items
unsigned	m_plate_switcher_version { unsigned(-1) }
bool	m_plate_switcher_scrollbar { false }
GLToolbar	m_assemble_view_toolbar
IMReturnToolbar	m_return_toolbar
Vec2i32	m_canvas_toolbar_pos = {140, 5}
float	m_sc {1}
float	m_paint_toolbar_width
bool	m_collapse_toolbar_enabled {true}
GLToolbar *	m_collapse_toolbar {nullptr}
std::function< CollapseSide()>	m_collapse_side
bool	m_plate_chrome_enabled {true}
bool	m_design_canvas {false}
bool	m_show_bed {true}
bool	m_sinking_contours_enabled {true}
GLModel	m_cad_grid_minor
GLModel	m_cad_grid_major
BoundingBoxf	m_cad_grid_bb
Vec2d	m_cad_grid_center
bool	m_cad_grid_valid {false}
ECanvasType	m_canvas_type
bool	m_studio_lighting {false}
std::array< ClippingPlane, 2 >	m_clipping_planes
ClippingPlane	m_camera_clipping_plane
bool	m_use_clipping_planes
std::shared_ptr< SectionView >	m_section_view { std::make_shared<SectionView>(this) }
std::map< const GLVolume *, MeshClipper >	m_section_view_caps
bool	m_alt_wheel_used { false }
std::array< SlaCap, 2 >	m_sla_caps
std::string	m_sidebar_field
bool	m_extra_frame_requested
bool	m_event_handlers_bound { false }
GLVolumeCollection	m_volumes
GCodeViewer	m_gcode_viewer
RenderTimer	m_render_timer
Selection	m_selection
const DynamicPrintConfig *	m_config
Model *	m_model
BackgroundSlicingProcess *	m_process
bool	m_requires_check_outside_state { false }
std::array< unsigned int, 2 >	m_old_size { 0, 0 }
bool	m_is_touchpad_navigation { false }
bool	m_dirty
bool	m_overlay_dirty { false }
bool	m_initialized
bool	m_render_preview { true }
bool	m_enable_render { true }
bool	m_apply_zoom_to_volumes_filter
bool	m_picking_enabled
bool	m_moving_enabled
bool	m_dynamic_background_enabled
bool	m_multisample_allowed
bool	m_moving
KeyDown	m_key_down
SelectionEdit	m_selection_edit
bool	m_camera_movement
bool	m_toolpath_outside { false }
ECursorType	m_cursor_type
GLSelectionRectangle	m_rectangle_selection
bool	m_navigator_dragging { false }
std::vector< int >	m_hover_volume_idxs
std::vector< int >	m_hover_plate_idxs
bool	m_inactive_plates_hidden { false }
int	m_hover_ghost_head { -1 }
int	m_hover_ghost_plate { -1 }
float	m_explosion_ratio = 1.0
Vec3d	m_rotation_center { 0.0, 0.0, 0.0}
Camera	camera
bool	m_render_sla_auxiliaries
std::string	m_color_by
bool	m_reload_delayed
RenderStats	m_render_stats
FrameProfiler	m_frame_profiler
bool	m_benchmarking { false }
std::chrono::time_point< std::chrono::steady_clock >	m_last_frame_start_time { std::chrono::steady_clock::now() }
int	m_imgui_undo_redo_hovered_pos { -1 }
int	m_mouse_wheel { 0 }
int	m_selected_extruder
Labels	m_labels
CenterOfMass	m_center_of_mass
Tooltip	m_tooltip
bool	m_tooltip_enabled { true }
Slope	m_slope
OrientSettings	m_orient_settings_fff
OrientSettings	m_orient_settings_sla
ArrangeSettings	m_arrange_settings_fff
ArrangeSettings	m_arrange_settings_sla
ArrangeSettings	m_arrange_settings_fff_seq_print
bool	m_show_world_axes {true}
Bed3D::Axes	m_axes
int	auto_orient_count = 0
int	auto_arrange_count = 0
int	split_to_objects_count = 0
int	split_to_part_count = 0
int	custom_height_count = 0
int	assembly_view_count = 0
std::vector< float >	m_gcode_layers_times_cache

Static Private Attributes
static const double	DefaultCameraZoomToBoxMarginFactor = 1.25
static const double	DefaultCameraZoomToBedMarginFactor = 2.00
static const double	DefaultCameraZoomToPlateMarginFactor = 1.25
static int	s_frames_in_progress = 0

Detailed Description

Class Documentation

◆ Slic3r::GUI::GLCanvas3D::ArrangeSettings

struct Slic3r::GUI::GLCanvas3D::ArrangeSettings

Class Members
float	accuracy = 0.65f
bool	align_to_y_axis = false
bool	allow_multi_materials_on_same_plate = true
bool	avoid_extrusion_cali_region = true
float	distance = 0.f
bool	enable_rotation = false
bool	is_seq_print = false

◆ Slic3r::GUI::GLCanvas3D::OrientSettings

struct Slic3r::GUI::GLCanvas3D::OrientSettings

Class Members
bool	enable_rotation = false
bool	min_area = true
float	overhang_angle = 60.f

◆ Slic3r::GUI::GLCanvas3D::KeyDown

struct Slic3r::GUI::GLCanvas3D::KeyDown

Class Members
int	code = WXK_NONE
bool	repeat = false

Member Enumeration Documentation

◆ ECameraNavigationType

enum class Slic3r::GUI::GLCanvas3D::ECameraNavigationType : unsigned char

strongprivate

Enumerator
Mouse
Gesture

    {
        Mouse,
        Gesture
    };

◆ ECanvasType

enum Slic3r::GUI::GLCanvas3D::ECanvasType

Enumerator
CanvasView3D
CanvasPreview
CanvasAssembleView

    {
        CanvasView3D = 0,
        CanvasPreview = 1,
        CanvasAssembleView = 2,
    };

◆ ECursorType

enum Slic3r::GUI::GLCanvas3D::ECursorType : unsigned char

Enumerator
Standard
Cross

    {
        Standard,
        Cross
    };

◆ EShadowMode

enum class Slic3r::GUI::GLCanvas3D::EShadowMode

strongprivate

Enumerator
Off
Static
Orbit

1511{ Off, Static, Orbit };

◆ EWarning

enum class Slic3r::GUI::GLCanvas3D::EWarning

strongprivate

Enumerator
ObjectOutside
ToolpathOutside
SlaSupportsOutside
SomethingNotShown
ObjectClashed
ObjectLimited
GCodeConflict
ToolHeightOutside
TPUPrintableError
FilamentPrintableError
LeftExtruderPrintableError
RightExtruderPrintableError
MultiExtruderPrintableError
MultiExtruderHeightOutside
FilamentUnPrintableOnFirstLayer
MixUsePLAAndPETG
PrimeTowerOutside
NozzleFilamentIncompatible
MixtureFilamentIncompatible
SingleExtruderMixedFilament
FlushingVolumeZero

                        {
        ObjectOutside,
        ToolpathOutside,
        SlaSupportsOutside,
        SomethingNotShown,
        ObjectClashed,
        ObjectLimited,
        GCodeConflict,
        ToolHeightOutside,
        TPUPrintableError,
        FilamentPrintableError,
        LeftExtruderPrintableError, // before slice
        RightExtruderPrintableError, // before slice
        MultiExtruderPrintableError,      // after slice
        MultiExtruderHeightOutside,       // after slice
        FilamentUnPrintableOnFirstLayer,
        MixUsePLAAndPETG,
        PrimeTowerOutside,
        NozzleFilamentIncompatible,
        MixtureFilamentIncompatible,
        SingleExtruderMixedFilament,
        FlushingVolumeZero
    };

◆ MouseAction

enum class Slic3r::GUI::GLCanvas3D::MouseAction

strong

Enumerator
None
Pan
Rotation

1299{ None, Pan, Rotation };

Slic3r::ConstraintReject::None

@ None

Definition SketchEngine.hpp:180

◆ MouseButton

enum class Slic3r::GUI::GLCanvas3D::MouseButton

strong

Enumerator
None
Left
Middle
Right

1298{ None, Left, Middle, Right };

Slic3r::GUI::CollapseSide::Right

@ Right

Definition GLToolbar.hpp:462

Slic3r::GUI::CollapseSide::Left

@ Left

Definition GLToolbar.hpp:462

Constructor & Destructor Documentation

◆ GLCanvas3D()

Slic3r::GUI::GLCanvas3D::GLCanvas3D	(	wxGLCanvas *	canvas,
		Bed3D &	bed )

explicit

    : m_canvas(canvas)
    , m_context(nullptr)
    , m_bed(bed)
#if ENABLE_RETINA_GL
    , m_retina_helper(nullptr)
#endif
    , m_in_render(false)
    , m_main_toolbar(GLToolbar::Normal, "Main")
    , m_separator_toolbar(GLToolbar::Normal, "Separator")
    , m_assemble_view_toolbar(GLToolbar::Normal, "Assembly_View")
    , m_return_toolbar()
    , m_canvas_type(ECanvasType::CanvasView3D)
    , m_gizmos(*this)
    , m_use_clipping_planes(false)
    , m_sidebar_field("")
    , m_extra_frame_requested(false)
    , m_config(nullptr)
    , m_process(nullptr)
    , m_model(nullptr)
    , m_dirty(true)
    , m_initialized(false)
    , m_apply_zoom_to_volumes_filter(false)
    , m_picking_enabled(false)
    , m_moving_enabled(false)
    , m_dynamic_background_enabled(false)
    , m_multisample_allowed(false)
    , m_moving(false)
    , m_camera_movement(false)
    , m_cursor_type(Standard)
    , m_color_by("volume")
    , m_reload_delayed(false)
    , m_render_sla_auxiliaries(true)
    , m_labels(*this)
    , m_slope(m_volumes)
{
    if (m_canvas != nullptr) {
        m_timer.SetOwner(m_canvas);
        m_render_timer.SetOwner(m_canvas);
#if ENABLE_RETINA_GL
        m_retina_helper.reset(new RetinaHelper(canvas));
#endif // ENABLE_RETINA_GL
    }
    m_timer_set_color.Bind(wxEVT_TIMER, &GLCanvas3D::on_set_color_timer, this);
    m_fps_overlay_timer.Bind(wxEVT_TIMER, &GLCanvas3D::on_fps_overlay_timer, this);
    load_arrange_settings();
 
    m_selection.set_volumes(&m_volumes.volumes);
 
    const wxString alt   = GUI::shortkey_alt_prefix();
 
    m_shortcuts_assembly_view = {
        {_L("Left mouse button"),       _L("Object selection")},
        {alt + _L("Left mouse button"), _L("Part selection")},
        {_L("1~16 number keys"),        _L("Number keys can quickly change the color of objects")},
    };
}

References GLCanvas3D(), _L, CanvasView3D, ENABLE_RETINA_GL, load_arrange_settings(), m_apply_zoom_to_volumes_filter, m_assemble_view_toolbar, m_bed, m_camera_movement, m_canvas, m_canvas_type, m_color_by, m_config, m_context, m_cursor_type, m_dirty, m_dynamic_background_enabled, m_extra_frame_requested, m_fps_overlay_timer, m_gizmos, m_in_render, m_initialized, m_labels, m_main_toolbar, m_model, m_moving, m_moving_enabled, m_multisample_allowed, m_picking_enabled, m_process, m_reload_delayed, m_render_sla_auxiliaries, m_render_timer, m_return_toolbar, m_selection, m_separator_toolbar, m_shortcuts_assembly_view, m_sidebar_field, m_slope, m_timer, m_timer_set_color, m_use_clipping_planes, m_volumes, Slic3r::GUI::Normal, on_fps_overlay_timer(), on_set_color_timer(), Slic3r::GUI::shortkey_alt_prefix(), and Standard.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~GLCanvas3D()

Slic3r::GUI::GLCanvas3D::~GLCanvas3D ( )

{
    if (_set_current()) {
        m_scene_cache.reset();
        m_frame_profiler.reset();
        if (m_fxaa_texture_id != 0) {
            glsafe(::glDeleteTextures(1, &m_fxaa_texture_id));
            m_fxaa_texture_id = 0;
        }
        if (m_ssao_color_texture_id != 0) {
            glsafe(::glDeleteTextures(1, &m_ssao_color_texture_id));
            m_ssao_color_texture_id = 0;
        }
        if (m_ssao_depth_texture_id != 0) {
            glsafe(::glDeleteTextures(1, &m_ssao_depth_texture_id));
            m_ssao_depth_texture_id = 0;
        }
        if (m_shadow_map_texture_id != 0) {
            glsafe(::glDeleteTextures(1, &m_shadow_map_texture_id));
            m_shadow_map_texture_id = 0;
        }
        if (m_shadow_map_fbo != 0) {
            glsafe(::glDeleteFramebuffers(1, &m_shadow_map_fbo));
            m_shadow_map_fbo = 0;
        }
        m_plate_shadow_mask.reset();
        m_section_view_caps.clear();
    }
    m_plate_shadow_mask_key.clear();
    if (m_section_view->owner == this)
        m_section_view->owner = nullptr;
 
    reset_volumes();
 
    m_sel_plate_toolbar.del_all_item();
    m_sel_plate_toolbar.del_stats_item();
    m_plate_switcher_items.clear();
}

References _set_current(), glDeleteFramebuffers, glDeleteTextures, glsafe, m_frame_profiler, m_fxaa_texture_id, m_plate_shadow_mask, m_plate_shadow_mask_key, m_plate_switcher_items, m_scene_cache, m_section_view, m_section_view_caps, m_sel_plate_toolbar, m_shadow_map_fbo, m_shadow_map_texture_id, m_ssao_color_texture_id, m_ssao_depth_texture_id, and reset_volumes().

Here is the call graph for this function:

Member Function Documentation

◆ _bind_gcode_shadow_map()

bool Slic3r::GUI::GLCanvas3D::_bind_gcode_shadow_map ( bool bind ) const

private

{
    if (!m_shadow_map_valid || m_shadow_map_texture_id == 0 || m_shadow_map_size == 0)
        return false;
    glsafe(::glActiveTexture(GL_TEXTURE4));
    glsafe(::glBindTexture(GL_TEXTURE_2D, bind ? m_shadow_map_texture_id : 0));
    glsafe(::glActiveTexture(GL_TEXTURE0));
    return true;
}

References _bind_gcode_shadow_map(), GL_TEXTURE0, GL_TEXTURE4, GL_TEXTURE_2D, glActiveTexture, glBindTexture, glsafe, m_shadow_map_size, m_shadow_map_texture_id, and m_shadow_map_valid.

Referenced by _bind_gcode_shadow_map(), _render_gcode(), and _render_gcode_translucent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _can_reuse_cached_scene()

bool Slic3r::GUI::GLCanvas3D::_can_reuse_cached_scene ( const Camera & camera ) const

private

{
    return _is_scene_cacheable() && m_scene_cache.matches(_scene_cache_key(camera));
}

References _can_reuse_cached_scene(), _is_scene_cacheable(), _scene_cache_key(), camera, and m_scene_cache.

Referenced by _can_reuse_cached_scene(), and _render_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _capture_scene_cache()

void Slic3r::GUI::GLCanvas3D::_capture_scene_cache ( const Camera & camera )

private

{
    if (!_is_scene_cache_enabled()) {
        m_scene_cache.reset();
        return;
    }
 
    if (!_is_scene_cacheable()) {
        m_scene_cache.invalidate();
        return;
    }
 
    m_scene_cache.capture(_scene_cache_key(camera));
}

References _capture_scene_cache(), _is_scene_cache_enabled(), _is_scene_cacheable(), _scene_cache_key(), camera, and m_scene_cache.

Referenced by _capture_scene_cache(), and _render_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _check_and_update_toolbar_icon_scale()

void Slic3r::GUI::GLCanvas3D::_check_and_update_toolbar_icon_scale ( )

private

{
    // Update collapse toolbar
    GLToolbar& collapse_toolbar = this->collapse_toolbar();
    collapse_toolbar.set_enabled(collapse_side() != CollapseSide::None);
 
    // Don't update a toolbar scale, when we are on a Preview. Asked of this canvas, not of the
    // plater: the Design tab's canvas is on screen while the plater's current view may be Preview.
    if (m_canvas_type == CanvasPreview) {
        IMSlider   *m_layers_slider = get_gcode_viewer().get_layers_slider();
        IMSlider   *m_moves_slider  = get_gcode_viewer().get_moves_slider();
        float sc              = get_scale();
#ifdef WIN32
        int dpi = get_dpi_for_window(wxGetApp().GetTopWindow());
        sc *= (float) dpi / (float) DPI_DEFAULT;
#endif // WIN32
 
        m_layers_slider->set_scale(sc * GCODE_VIEWER_SLIDER_SCALE);
        m_moves_slider->set_scale(sc * GCODE_VIEWER_SLIDER_SCALE);
        m_gcode_viewer.set_scale(sc);
 
        auto *m_notification = wxGetApp().plater()->get_notification_manager();
        m_notification->set_scale(sc);
        return;
    }
 
    float scale = wxGetApp().toolbar_icon_scale() * get_scale();
    Size cnv_size = get_canvas_size();
 
    //BBS: GUI refactor: GLToolbar
    int size_i = int(GLToolbar::Default_Icons_Size * scale);
    // force even size
    if (size_i % 2 != 0)
        size_i -= 1;
    float size   = size_i;
 
    // Set current size for all top toolbars. It will be used for next calculations
    //BBS: GUI refactor: GLToolbar
    m_main_toolbar.set_icons_size(size);
    m_assemble_view_toolbar.set_icons_size(size);
    m_separator_toolbar.set_icons_size(size);
    collapse_toolbar.set_icons_size(size / 2.0);
    m_gizmos.set_overlay_icon_size(size);
 
    //BBS: GUI refactor: GLToolbar
#if BBS_TOOLBAR_ON_TOP
    float collapse_toolbar_width = collapse_toolbar.is_enabled() ? collapse_toolbar.get_width() : 0;
 
    float top_tb_width = m_main_toolbar.get_width() + m_gizmos.get_scaled_total_width() + m_assemble_view_toolbar.get_width() + m_separator_toolbar.get_width() + collapse_toolbar_width * 2;
    int   items_cnt = m_main_toolbar.get_visible_items_cnt() + m_gizmos.get_selectable_icons_cnt() + m_assemble_view_toolbar.get_visible_items_cnt() + m_separator_toolbar.get_visible_items_cnt() + collapse_toolbar.get_visible_items_cnt();
    float noitems_width = top_tb_width - size * items_cnt; // width of separators and borders in top toolbars
 
    // calculate scale needed for items in all top toolbars
    float new_h_scale = (cnv_size.get_width() - noitems_width) / (items_cnt * GLToolbar::Default_Icons_Size);
 
    //for protect
    if (new_h_scale <= 0) {
        new_h_scale = 1;
    }
 
    //use the same value as horizon
    float new_v_scale = new_h_scale;
#else
    float top_tb_width = = collapse_toolbar.get_width();
    int   items_cnt = collapse_toolbar.get_visible_items_cnt();
    float noitems_width = top_tb_width - size * items_cnt; // width of separators and borders in top toolbars
 
    // calculate scale needed for items in all top toolbars
    float new_h_scale = (cnv_size.get_width() - noitems_width) / (items_cnt * GLToolbar::Default_Icons_Size);
 
    //items_cnt = m_main_toolbar.get_visible_items_cnt() + m_gizmos.get_selectable_icons_cnt() + 3; // +3 means a place for top and view toolbars and separators in gizmos toolbar
 
    // calculate scale needed for items in the gizmos toolbar
    items_cnt = m_main_toolbar.get_visible_items_cnt() + m_gizmos.get_selectable_icons_cnt() + m_assemble_view_toolbar.get_visible_items_cnt();
    float new_v_scale = cnv_size.get_height() / (items_cnt * GLGizmosManager::Default_Icons_Size);
#endif
 
    // set minimum scale as a auto scale for the toolbars
    float new_scale = std::min(new_h_scale, new_v_scale);
    new_scale /= get_scale();
    // Only a canvas with toolbars to fit sets the shared size: a collapse button alone (the Design
    // tab's canvas) always fits at the largest.
    if (items_cnt > collapse_toolbar.get_visible_items_cnt() && fabs(new_scale - scale) > 0.05) // scale is changed by 5% and more
        wxGetApp().set_auto_toolbar_icon_scale(new_scale);
}

References _check_and_update_toolbar_icon_scale(), CanvasPreview, collapse_side(), collapse_toolbar(), Slic3r::GUI::GLGizmosManager::Default_Icons_Size, Slic3r::GUI::GLToolbar::Default_Icons_Size, Slic3r::GUI::DPI_DEFAULT, Slic3r::GUI::GCODE_VIEWER_SLIDER_SCALE, get_canvas_size(), Slic3r::GUI::get_dpi_for_window(), get_gcode_viewer(), Slic3r::GUI::Size::get_height(), get_scale(), Slic3r::GUI::Size::get_width(), m_assemble_view_toolbar, m_canvas_type, m_gcode_viewer, m_gizmos, m_main_toolbar, m_separator_toolbar, Slic3r::GUI::None, scale(), and Slic3r::GUI::IMSlider::set_scale().

Referenced by _check_and_update_toolbar_icon_scale(), and _render_overlays().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _current_plate_box()

BoundingBoxf3 Slic3r::GUI::GLCanvas3D::_current_plate_box ( ) const

private

{
    // Design tab: its own bed stands in for the current plate (see _render_platelist).
    const BuildVolume& build_volume = m_bed.build_volume();
    if (m_design_canvas && build_volume.valid()) {
        // Flat at z = 0 like the plate's own box. Merged, as PartPlate builds it: the min/max
        // constructor leaves a flat box undefined.
        const BoundingBoxf bb = build_volume.bounding_volume2d();
        BoundingBoxf3      box;
        box.merge(Vec3d(bb.min.x(), bb.min.y(), 0.));
        box.merge(Vec3d(bb.max.x(), bb.max.y(), 0.));
        return box;
    }
    PartPlate* curr_plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
    return curr_plate != nullptr ? curr_plate->get_bounding_box() : BoundingBoxf3();
}

References _current_plate_box(), Slic3r::BuildVolume::bounding_volume2d(), Slic3r::GUI::PartPlate::get_bounding_box(), m_bed, m_design_canvas, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, and Slic3r::BuildVolume::valid().

Referenced by _current_plate_box(), get_camera_orbit_target(), and volumes_bounding_box().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _deactivate_arrange_menu()

bool Slic3r::GUI::GLCanvas3D::_deactivate_arrange_menu ( )

private

{
    if (m_main_toolbar.is_item_pressed("arrange")) {
        m_main_toolbar.force_right_action(m_main_toolbar.get_item_id("arrange"), *this);
        return true;
    }
 
    return false;
}

References _deactivate_arrange_menu(), and m_main_toolbar.

Referenced by _deactivate_arrange_menu(), on_char(), and on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _deactivate_collapse_toolbar_items()

bool Slic3r::GUI::GLCanvas3D::_deactivate_collapse_toolbar_items ( )

private

{
    GLToolbar& collapse_toolbar = this->collapse_toolbar();
    if (collapse_toolbar.is_item_pressed("print")) {
        collapse_toolbar.force_left_action(collapse_toolbar.get_item_id("print"), *this);
        return true;
    }
 
    return false;
}

References _deactivate_collapse_toolbar_items(), and collapse_toolbar().

Referenced by _deactivate_collapse_toolbar_items().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _deactivate_layersediting_menu()

bool Slic3r::GUI::GLCanvas3D::_deactivate_layersediting_menu ( )

private

{
    if (m_main_toolbar.is_item_pressed("layersediting")) {
        m_main_toolbar.force_left_action(m_main_toolbar.get_item_id("layersediting"), *this);
        return true;
    }
 
    return false;
}

References _deactivate_layersediting_menu(), and m_main_toolbar.

Referenced by _deactivate_layersediting_menu(), and on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _deactivate_orient_menu()

bool Slic3r::GUI::GLCanvas3D::_deactivate_orient_menu ( )

private

{
    if (m_main_toolbar.is_item_pressed("orient")) {
        m_main_toolbar.force_right_action(m_main_toolbar.get_item_id("orient"), *this);
        return true;
    }
 
    return false;
}

References _deactivate_orient_menu(), and m_main_toolbar.

Referenced by _deactivate_orient_menu(), on_char(), and on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _get_current_partplate_print_volume()

BoundingBoxf3 Slic3r::GUI::GLCanvas3D::_get_current_partplate_print_volume ( )

private

{
    BoundingBoxf3 test_volume;
    if (m_process && m_config)
    {
        BoundingBoxf3 plate_bb = m_process->get_current_plate()->get_bounding_box(false);
        BoundingBoxf3 print_volume({ plate_bb.min(0), plate_bb.min(1), 0.0 }, { plate_bb.max(0), plate_bb.max(1), m_config->opt_float("printable_height") });
        // Allow the objects to protrude below the print bed
        print_volume.min(2) = -1e10;
        print_volume.min(0) -= Slic3r::BuildVolume::BedEpsilon;
        print_volume.min(1) -= Slic3r::BuildVolume::BedEpsilon;
        print_volume.max(0) += Slic3r::BuildVolume::BedEpsilon;
        print_volume.max(1) += Slic3r::BuildVolume::BedEpsilon;
        test_volume = print_volume;
    }
    else
        test_volume = BoundingBoxf3();
 
    return test_volume;
}

References Slic3r::BuildVolume::BedEpsilon, m_config, m_process, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, and Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min.

Referenced by _render_background().

Here is the caller graph for this function:

◆ _get_effective_fps_cap()

int Slic3r::GUI::GLCanvas3D::_get_effective_fps_cap ( ) const

private

{
    if (wxGetApp().app_config == nullptr)
        return 0;
 
    int fps_cap = 0;
    try {
        fps_cap = std::stoi(wxGetApp().app_config->get(SETTING_OPENGL_FPS_CAP));
    }
    catch (...) {
        fps_cap = 0;
    }
 
    fps_cap = std::max(0, std::min(fps_cap, 240));
 
    return fps_cap;
}

References _get_effective_fps_cap(), and SETTING_OPENGL_FPS_CAP.

Referenced by _get_effective_fps_cap(), and on_idle().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _get_section_view_plane()

ClippingPlane Slic3r::GUI::GLCanvas3D::_get_section_view_plane ( ) const

private

{
    const SectionView& section_view = *m_section_view;
    if (section_view.ratio == 0.)
        return ClippingPlane::ClipsNothing();
 
    // The owner's objects, so Preview cuts where Prepare does.
    const GLCanvas3D& owner = section_view.owner != nullptr ? *section_view.owner : *this;
    BoundingBoxf3 box = owner.volumes_bounding_box(true);
    if (!box.defined)
        box = owner.volumes_bounding_box();
    // G-code without objects: its toolpaths, merged by corner as a flat box is undefined.
    if (!box.defined && m_gcode_viewer.has_data()) {
        box.merge(m_gcode_viewer.get_paths_bounding_box().min);
        box.merge(m_gcode_viewer.get_paths_bounding_box().max);
    }
    if (!box.defined)
        return ClippingPlane::ClipsNothing();
 
    // Sweeps the bounding sphere from the camera side (0) to the far side (1), as ObjectClipper does.
    const double radius = box.radius();
    return ClippingPlane(section_view.normal, section_view.normal.dot(box.center()) + radius - 2. * radius * section_view.ratio);
}

References GLCanvas3D(), _get_section_view_plane(), Slic3r::BoundingBox3Base< PointType >::center(), Slic3r::GUI::ClippingPlane::ClipsNothing(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::defined, m_gcode_viewer, m_section_view, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::GUI::GLCanvas3D::SectionView::normal, Slic3r::GUI::GLCanvas3D::SectionView::owner, Slic3r::BoundingBox3Base< PointType >::radius(), Slic3r::GUI::GLCanvas3D::SectionView::ratio, and volumes_bounding_box().

Referenced by _get_section_view_plane(), _get_volumes_clipping_plane(), _render_scene(), and _render_section_view_caps().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _get_volumes_clipping_plane()

ClippingPlane Slic3r::GUI::GLCanvas3D::_get_volumes_clipping_plane ( ) const

private

{
    const std::optional<ClippingPlane> gizmo_plane = m_gizmos.get_clipping_plane();
    return gizmo_plane.has_value() ? *gizmo_plane : _get_section_view_plane().inverted_normal();
}

References _get_section_view_plane(), _get_volumes_clipping_plane(), and m_gizmos.

Referenced by _get_volumes_clipping_plane(), _render_objects(), and get_raycaster_clipping_plane().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _hides_inactive_plates()

bool Slic3r::GUI::GLCanvas3D::_hides_inactive_plates ( ) const

private

{
    return m_canvas_type == ECanvasType::CanvasView3D && !m_design_canvas && wxGetApp().focus_mode();
}

References _hides_inactive_plates(), CanvasView3D, m_canvas_type, and m_design_canvas.

Referenced by _hides_inactive_plates(), _render_bed(), _render_plate_switcher(), _render_platelist(), _update_inactive_plates_visibility(), and zoom_to_plate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _init_assemble_view_toolbar()

bool Slic3r::GUI::GLCanvas3D::_init_assemble_view_toolbar ( )

private

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": enter,  m_assemble_view_toolbar.is_enabled=" << m_assemble_view_toolbar.is_enabled() << "\n";
    if (!m_assemble_view_toolbar.is_enabled())
        return true;
 
    BackgroundTexture::Metadata background_data;
    background_data.filename = m_is_dark ? "toolbar_background_dark.png" : "toolbar_background.png";
    background_data.left = 16;
    background_data.top = 16;
    background_data.right = 16;
    background_data.bottom = 16;
 
    if (!m_assemble_view_toolbar.init(background_data))
    {
        // unable to init the toolbar texture, disable it
        m_assemble_view_toolbar.set_enabled(false);
        return true;
    }
 
    m_assemble_view_toolbar.set_layout_type(GLToolbar::Layout::Horizontal);
    //BBS: assemble toolbar is at the top and right, we don't need the rounded-corner effect at the left side and the top side
    m_assemble_view_toolbar.set_horizontal_orientation(GLToolbar::Layout::HO_Left);
    m_assemble_view_toolbar.set_vertical_orientation(GLToolbar::Layout::VO_Top);
    m_assemble_view_toolbar.set_border(4.0f);
    m_assemble_view_toolbar.set_separator_size(10);
    m_assemble_view_toolbar.set_gap_size(4);
 
    m_assemble_view_toolbar.del_all_item();
 
    GLToolbarItem::Data item;
    item.name = "assembly_view";
    item.icon_filename = m_is_dark ? "toolbar_assemble_dark.svg" : "toolbar_assemble.svg";
    item.tooltip = _utf8(L("Assembly View"));
    item.sprite_id = 1;
    item.left.toggable = false;
    item.left.action_callback = [this]() { if (m_canvas != nullptr) wxPostEvent(m_canvas, SimpleEvent(EVT_GLVIEWTOOLBAR_ASSEMBLE)); };
    item.left.render_callback = GLToolbarItem::Default_Render_Callback;
    item.visible = true;
    item.visibility_callback = []()->bool { return true; };
    item.enabling_callback = []()->bool {
        return wxGetApp().plater()->has_assmeble_view();
    };
    if (!m_assemble_view_toolbar.add_item(item))
        return false;
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Finished Successfully\n";
    return true;
}

Referenced by _init_toolbars().

Here is the caller graph for this function:

◆ _init_collapse_toolbar()

bool Slic3r::GUI::GLCanvas3D::_init_collapse_toolbar ( )

private

{
    if (m_collapse_toolbar == nullptr)
        return wxGetApp().plater()->init_collapse_toolbar();
 
    // Its owner laid it out; the background needs the GL context.
    BackgroundTexture::Metadata background_data;
    background_data.filename = m_is_dark ? "toolbar_background_dark.png" : "toolbar_background.png";
    background_data.left = 16;
    background_data.top = 16;
    background_data.right = 16;
    background_data.bottom = 16;
    return m_collapse_toolbar->init(background_data);
}

References Slic3r::GUI::BackgroundTexture::Metadata::bottom, Slic3r::GUI::BackgroundTexture::Metadata::filename, Slic3r::GUI::BackgroundTexture::Metadata::left, m_collapse_toolbar, m_is_dark, Slic3r::GUI::BackgroundTexture::Metadata::right, and Slic3r::GUI::BackgroundTexture::Metadata::top.

Referenced by _init_toolbars().

Here is the caller graph for this function:

◆ _init_main_toolbar()

bool Slic3r::GUI::GLCanvas3D::_init_main_toolbar ( )

private

{
    if (!m_main_toolbar.is_enabled())
        return true;
 
    BackgroundTexture::Metadata background_data;
    background_data.filename = m_is_dark ? "toolbar_background_dark.png" : "toolbar_background.png";
    background_data.left = 16;
    background_data.top = 16;
    background_data.right = 16;
    background_data.bottom = 16;
 
    if (!m_main_toolbar.init(background_data))
    {
        // unable to init the toolbar texture, disable it
        m_main_toolbar.set_enabled(false);
        return true;
    }
    // init arrow
    if (!m_main_toolbar.init_arrow("toolbar_arrow.svg"))
        BOOST_LOG_TRIVIAL(error) << "Main toolbar failed to load arrow texture.";
 
    // m_gizmos is created at constructor, thus we can init arrow here.
    if (!m_gizmos.init_arrow("toolbar_arrow.svg"))
        BOOST_LOG_TRIVIAL(error) << "Gizmos manager failed to load arrow texture.";
 
    m_main_toolbar.set_layout_type(GLToolbar::Layout::Horizontal);
    //BBS: main toolbar is at the top and left, we don't need the rounded-corner effect at the right side and the top side
    m_main_toolbar.set_horizontal_orientation(GLToolbar::Layout::HO_Right);
    m_main_toolbar.set_vertical_orientation(GLToolbar::Layout::VO_Top);
    m_main_toolbar.set_border(4.0f);
    m_main_toolbar.set_separator_size(4);
    m_main_toolbar.set_gap_size(4);
 
    m_main_toolbar.del_all_item();
 
    GLToolbarItem::Data item;
 
    item.name = "add";
    item.icon_filename = m_is_dark ? "toolbar_open_dark.svg" : "toolbar_open.svg";
    item.sprite_id = 0;
    item.left.action_callback = [this]() { if (m_canvas != nullptr) wxPostEvent(m_canvas, SimpleEvent(EVT_GLTOOLBAR_ADD)); };
    item.enabling_callback = []()->bool {return wxGetApp().plater()->can_add_model(); };
    if (!m_main_toolbar.add_item(item))
        return false;
 
    item.name = "addplate";
    item.icon_filename = m_is_dark ? "toolbar_add_plate_dark.svg" : "toolbar_add_plate.svg";
    item.tooltip = _utf8(L("Add plate"));
    item.sprite_id++;
    item.left.action_callback = [this]() { if (m_canvas != nullptr) wxPostEvent(m_canvas, SimpleEvent(EVT_GLTOOLBAR_ADD_PLATE)); };
    item.enabling_callback = []()->bool {return wxGetApp().plater()->can_add_plate(); };
    if (!m_main_toolbar.add_item(item))
        return false;
 
    item.name = "orient";
    item.icon_filename = m_is_dark ? "toolbar_orient_dark.svg" : "toolbar_orient.svg";
    item.sprite_id++;
    item.left.render_callback = nullptr;
    item.enabling_callback = []()->bool { return wxGetApp().plater()->can_arrange(); };
    item.left.toggable = false;  // allow right mouse click
    //BBS: GUI refactor: adjust the main toolbar position
    item.left.action_callback = [this]() {
        if (m_canvas != nullptr)
        {
            wxGetApp().plater()->set_prepare_state(Job::PREPARE_STATE_DEFAULT);
            wxGetApp().plater()->orient();
            //BBS do not show orient menu
            //_render_orient_menu(left, right, bottom, top);
            NetworkAgent* agent = GUI::wxGetApp().getAgent();
            if (agent) agent->track_update_property("auto_orient", std::to_string(++auto_orient_count));
        }
    };
    if (!m_main_toolbar.add_item(item))
        return false;
 
    item.name = "arrange";
    item.icon_filename = m_is_dark ? "toolbar_arrange_dark.svg" : "toolbar_arrange.svg";
    item.sprite_id++;
    item.left.action_callback = []() {};
    item.enabling_callback = []()->bool { return wxGetApp().plater()->can_arrange(); };
    item.left.toggable = true;
    //BBS: GUI refactor: adjust the main toolbar position
    item.left.render_callback = [this](float left, float right, float bottom, float top) {
        if (m_canvas != nullptr)
        {
            _render_arrange_menu(left, right, bottom, top);
            //_render_arrange_menu(0.5f * (left + right));
        }
    };
    if (!m_main_toolbar.add_item(item))
        return false;
 
    item.right.toggable = false;
    item.right.render_callback = GLToolbarItem::Default_Render_Callback;
 
    if (!m_main_toolbar.add_separator())
        return false;
 
    item.name = "more";
    item.icon_filename = m_is_dark ? "instance_add_dark.svg" : "instance_add.svg";
    item.sprite_id++;
    item.left.render_callback = nullptr;
    item.left.action_callback = [this]() { if (m_canvas != nullptr) wxPostEvent(m_canvas, SimpleEvent(EVT_GLTOOLBAR_MORE)); };
    item.visibility_callback = GLToolbarItem::Default_Visibility_Callback;
    item.left.toggable = false;
    item.enabling_callback = []()->bool { return wxGetApp().plater()->can_increase_instances(); };
    if (!m_main_toolbar.add_item(item))
        return false;
 
    item.name = "fewer";
    item.icon_filename = m_is_dark ? "instance_remove_dark.svg" : "instance_remove.svg";
    item.sprite_id++;
    item.left.render_callback = nullptr;
    item.left.action_callback = [this]() { if (m_canvas != nullptr) wxPostEvent(m_canvas, SimpleEvent(EVT_GLTOOLBAR_FEWER)); };
    item.visibility_callback = GLToolbarItem::Default_Visibility_Callback;
    item.left.toggable = false;
    item.enabling_callback = []()->bool { return wxGetApp().plater()->can_decrease_instances(); };
    if (!m_main_toolbar.add_item(item))
        return false;
 
    item.name = "splitobjects";
    item.icon_filename = m_is_dark ? "split_objects_dark.svg" : "split_objects.svg";
    item.tooltip = _utf8(L("Split to objects"));
    item.sprite_id++;
    item.left.render_callback = nullptr;
    item.left.action_callback = [this]() { if (m_canvas != nullptr) wxPostEvent(m_canvas, SimpleEvent(EVT_GLTOOLBAR_SPLIT_OBJECTS)); };
    item.visibility_callback = GLToolbarItem::Default_Visibility_Callback;
    item.left.toggable = false;
    item.enabling_callback = []()->bool { return wxGetApp().plater()->can_split_to_objects(); };
    if (!m_main_toolbar.add_item(item))
        return false;
 
    item.name = "splitvolumes";
    item.icon_filename = m_is_dark ? "split_parts_dark.svg" : "split_parts.svg";
    item.tooltip = _utf8(L("Split to parts"));
    item.sprite_id++;
    item.left.action_callback = [this]() { if (m_canvas != nullptr) wxPostEvent(m_canvas, SimpleEvent(EVT_GLTOOLBAR_SPLIT_VOLUMES)); };
    item.visibility_callback = GLToolbarItem::Default_Visibility_Callback;
    item.enabling_callback = []()->bool { return wxGetApp().plater()->can_split_to_volumes(); };
    if (!m_main_toolbar.add_item(item))
        return false;
 
    item.name = "layersediting";
    item.icon_filename = m_is_dark ? "toolbar_variable_layer_height_dark.svg" : "toolbar_variable_layer_height.svg";
    item.tooltip = _utf8(L("Variable layer height"));
    item.sprite_id++;
    item.left.toggable = true; // ORCA Closes popup if other toolbar icon clicked and it allows closing popup when clicked its button
    item.left.action_callback = [this]() { if (m_canvas != nullptr) wxPostEvent(m_canvas, SimpleEvent(EVT_GLTOOLBAR_LAYERSEDITING)); };
    item.visibility_callback = [this]()->bool {
        bool res = current_printer_technology() == ptFFF;
        // turns off if changing printer technology
        if (!res && m_main_toolbar.is_item_visible("layersediting") && m_main_toolbar.is_item_pressed("layersediting"))
            force_main_toolbar_left_action(get_main_toolbar_item_id("layersediting"));
 
        return res;
    };
    item.enabling_callback = []()->bool { return wxGetApp().plater()->can_layers_editing(); };
    if (!m_main_toolbar.add_item(item))
        return false;
 
    update_shortcut_tooltips();
    return true;
}

Referenced by _init_toolbars().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _init_return_toolbar()

bool Slic3r::GUI::GLCanvas3D::_init_return_toolbar ( )

private

{
    if (!m_return_toolbar.is_enabled())
        return true;
 
    return m_return_toolbar.init();
}

References m_return_toolbar.

Referenced by _init_toolbars().

Here is the caller graph for this function:

◆ _init_select_plate_toolbar()

bool Slic3r::GUI::GLCanvas3D::_init_select_plate_toolbar ( )

private

{
    std::string path = resources_dir() + "/images/";
    IMToolbarItem* item = new IMToolbarItem();
    // ORCA add dark mode support and load images with 2x resolution to prevent blurry image on hi-dpi screens
    std::string    ext  = m_is_dark ? "_dark.svg" : ".svg";
    bool result      = item->image_stats.load_from_svg_file(   path + "im_all_plates_stats"   + ext, false, false, false, 200);
    result = result && item->image_idle.load_from_svg_file(    path + "im_all_plates_idle"    + ext, false, false, false, 200);
    result = result && item->image_slicing.load_from_svg_file( path + "im_all_plates_slicing" + ext, false, false, false, 200);
    result = result && item->image_failed.load_from_svg_file(  path + "im_all_plates_failed"  + ext, false, false, false, 200);
    m_sel_plate_toolbar.m_all_plates_stats_item = item;
 
    return result;
}

References Slic3r::GUI::IMToolbarItem::image_failed, Slic3r::GUI::IMToolbarItem::image_idle, Slic3r::GUI::IMToolbarItem::image_slicing, Slic3r::GUI::IMToolbarItem::image_stats, Slic3r::GUI::GLTexture::load_from_svg_file(), m_is_dark, m_sel_plate_toolbar, and Slic3r::resources_dir().

Referenced by _init_toolbars(), and on_change_color_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _init_separator_toolbar()

bool Slic3r::GUI::GLCanvas3D::_init_separator_toolbar ( )

private

{
    if (!m_separator_toolbar.is_enabled())
        return true;
 
    BackgroundTexture::Metadata background_data;
    background_data.filename = m_is_dark ? "toolbar_background_dark.png" : "toolbar_background.png";
    background_data.left = 0;
    background_data.top = 0;
    background_data.right = 0;
    background_data.bottom = 0;
 
    if (!m_separator_toolbar.init(background_data))
    {
        // unable to init the toolbar texture, disable it
        m_separator_toolbar.set_enabled(false);
        return true;
    }
 
    m_separator_toolbar.set_layout_type(GLToolbar::Layout::Horizontal);
    //BBS: assemble toolbar is at the top and right, we don't need the rounded-corner effect at the left side and the top side
    m_separator_toolbar.set_horizontal_orientation(GLToolbar::Layout::HO_Left);
    m_separator_toolbar.set_vertical_orientation(GLToolbar::Layout::VO_Top);
    m_separator_toolbar.set_border(4.0f);
 
    m_separator_toolbar.del_all_item();
 
    GLToolbarItem::Data sperate_item;
    sperate_item.name = "start_seperator";
    sperate_item.icon_filename = "seperator.svg";
    sperate_item.sprite_id = 0;
    sperate_item.left.action_callback = []() {};
    sperate_item.visibility_callback = []()->bool { return true; };
    sperate_item.enabling_callback = []()->bool { return false; };
    if (!m_separator_toolbar.add_item(sperate_item))
        return false;
 
     return true;
}

Referenced by _init_toolbars().

Here is the caller graph for this function:

◆ _init_toolbars()

bool Slic3r::GUI::GLCanvas3D::_init_toolbars ( )

private

{
    if (!_init_main_toolbar())
        return false;
 
    //BBS: GUI refractor
    if (!_init_assemble_view_toolbar())
        return false;
 
    if (!_init_return_toolbar())
        return false;
 
    if (!_init_separator_toolbar())
        return false;
 
    if (!_init_select_plate_toolbar())
        return false;
 
#if 0
    if (!_init_view_toolbar())
        return false;
#endif
 
    if (!_init_collapse_toolbar())
        return false;
 
    return true;
}

References _init_assemble_view_toolbar(), _init_collapse_toolbar(), _init_main_toolbar(), _init_return_toolbar(), _init_select_plate_toolbar(), and _init_separator_toolbar().

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _is_any_volume_outside()

bool Slic3r::GUI::GLCanvas3D::_is_any_volume_outside ( ) const

private

{
    for (const GLVolume* volume : m_volumes.volumes) {
        if (volume != nullptr && volume->is_outside)
            return true;
    }
 
    return false;
}

References _is_any_volume_outside(), and m_volumes.

Referenced by _is_any_volume_outside(), _render_background(), and _set_warning_notification_if_needed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _is_below_plate_view_active()

bool Slic3r::GUI::GLCanvas3D::_is_below_plate_view_active ( ) const

private

{
    return dynamic_cast<const GLGizmoPainterBase*>(m_gizmos.get_current()) != nullptr && m_gizmos.is_hiding_instances();
}

References _is_below_plate_view_active(), and m_gizmos.

Referenced by _is_below_plate_view_active(), _render_below_plate_volumes(), _render_scene(), and is_bed_visible().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _is_fps_overlay_enabled()

bool Slic3r::GUI::GLCanvas3D::_is_fps_overlay_enabled ( ) const

private

{
    return !m_benchmarking && wxGetApp().app_config != nullptr && wxGetApp().app_config->get_bool(SETTING_OPENGL_SHOW_FPS_OVERLAY);
}

References _is_fps_overlay_enabled(), m_benchmarking, and SETTING_OPENGL_SHOW_FPS_OVERLAY.

Referenced by _is_fps_overlay_enabled(), _render_fps_overlay(), and _render_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _is_frame_skipping_enabled()

bool Slic3r::GUI::GLCanvas3D::_is_frame_skipping_enabled ( ) const

private

{
    return wxGetApp().app_config != nullptr && wxGetApp().app_config->get_bool(SETTING_OPENGL_SKIP_IDENTICAL_FRAMES);
}

References _is_frame_skipping_enabled(), and SETTING_OPENGL_SKIP_IDENTICAL_FRAMES.

Referenced by _is_frame_skipping_enabled(), and _render_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _is_fxaa_enabled()

bool Slic3r::GUI::GLCanvas3D::_is_fxaa_enabled ( ) const

private

{
    return wxGetApp().app_config != nullptr && wxGetApp().app_config->get_bool(SETTING_OPENGL_FXAA_ENABLED);
}

References _is_fxaa_enabled(), and SETTING_OPENGL_FXAA_ENABLED.

Referenced by _is_fxaa_enabled(), and _render_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _is_realistic_view_enabled()

bool Slic3r::GUI::GLCanvas3D::_is_realistic_view_enabled ( ) const

private

{
    const AppConfig* cfg = wxGetApp().app_config;
    if (cfg == nullptr || !cfg->get_bool(SETTING_OPENGL_REALISTIC_MODE))
        return false;
    // Prepare and Assemble follow the umbrella toggle alone; Preview needs its own opt-in.
    return m_canvas_type != ECanvasType::CanvasPreview || cfg->get_bool(SETTING_OPENGL_REALISTIC_PREVIEW);
}

References _is_realistic_view_enabled(), CanvasPreview, Slic3r::AppConfig::get_bool(), m_canvas_type, SETTING_OPENGL_REALISTIC_MODE, and SETTING_OPENGL_REALISTIC_PREVIEW.

Referenced by _is_realistic_view_enabled(), _is_ssao_enabled(), _render_gcode(), _render_objects(), _render_shadows(), and _static_light_dir_eye().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _is_render_timings_enabled()

bool Slic3r::GUI::GLCanvas3D::_is_render_timings_enabled ( ) const

private

{
    return !m_benchmarking && wxGetApp().app_config != nullptr && wxGetApp().app_config->get_bool(SETTING_OPENGL_SHOW_RENDER_TIMINGS);
}

References _is_render_timings_enabled(), m_benchmarking, and SETTING_OPENGL_SHOW_RENDER_TIMINGS.

Referenced by _is_render_timings_enabled(), _render_fps_overlay(), and _render_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _is_scene_cache_enabled()

bool Slic3r::GUI::GLCanvas3D::_is_scene_cache_enabled ( ) const

private

{
    return wxGetApp().app_config != nullptr && wxGetApp().app_config->get_bool(SETTING_OPENGL_SCENE_CACHE);
}

References _is_scene_cache_enabled(), and SETTING_OPENGL_SCENE_CACHE.

Referenced by _capture_scene_cache(), _is_scene_cache_enabled(), and _is_scene_cacheable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _is_scene_cacheable()

bool Slic3r::GUI::GLCanvas3D::_is_scene_cacheable ( ) const

private

{
    if (!_is_scene_cache_enabled())
        return false;
 
#ifdef SLIC3R_CAD
    // The Design tab draws its sketch overlay, ImGui included, inside the scene.
    if (m_design_sketch_tool != nullptr && m_design_sketch_tool->has_display())
        return false;
#endif
 
    // The scene follows the cursor during a drag, under a gizmo that draws at the cursor, and while
    // the cursor is on the layer height bar, where the object shader draws a band at its height.
    const GLGizmoBase* gizmo = m_gizmos.get_current();
    const bool cursor_on_layers_bar = is_layers_editing_enabled() &&
        m_layers_editing.bar_rect_contains(*this, (float)m_mouse.position.x(), (float)m_mouse.position.y());
    return !m_mouse.dragging && !m_gizmos.is_dragging() && !m_rectangle_selection.is_dragging() &&
           (gizmo == nullptr || !gizmo->render_follows_cursor()) && !cursor_on_layers_bar;
}

References _is_scene_cache_enabled(), _is_scene_cacheable(), is_layers_editing_enabled(), m_gizmos, m_layers_editing, m_mouse, m_rectangle_selection, and Slic3r::GUI::GLGizmoBase::render_follows_cursor().

Referenced by _can_reuse_cached_scene(), _capture_scene_cache(), and _is_scene_cacheable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _is_shown_on_screen()

bool Slic3r::GUI::GLCanvas3D::_is_shown_on_screen ( ) const

private

{
    return (m_canvas != nullptr) ? m_canvas->IsShownOnScreen() : false;
}

References m_canvas.

Referenced by _refresh_if_shown_on_screen(), _render_frame(), and on_idle().

Here is the caller graph for this function:

◆ _is_ssao_enabled()

bool Slic3r::GUI::GLCanvas3D::_is_ssao_enabled ( ) const

private

{
    if (wxGetApp().app_config == nullptr)
        return false;
    return _is_realistic_view_enabled() &&
           wxGetApp().app_config->get_bool(SETTING_OPENGL_PHONG_SSAO);
}

References _is_realistic_view_enabled(), _is_ssao_enabled(), and SETTING_OPENGL_PHONG_SSAO.

Referenced by _is_ssao_enabled(), and _render_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _is_xray_view_active()

bool Slic3r::GUI::GLCanvas3D::_is_xray_view_active ( ) const

private

{
    if (m_canvas_type == ECanvasType::CanvasPreview || !wxGetApp().plater()->is_show_xray())
        return false;
 
    // A painting gizmo and the layer height editor draw the object through their own shaders, and
    // would lose what they draw if X-Ray took the pass over.
    if (dynamic_cast<const GLGizmoPainterBase*>(m_gizmos.get_current()) != nullptr)
        return false;
    return !(m_picking_enabled && m_layers_editing.is_enabled() && m_layers_editing.last_object_id != -1 &&
             m_layers_editing.object_max_z() > 0.0f);
}

References _is_xray_view_active(), CanvasPreview, m_canvas_type, m_gizmos, m_layers_editing, m_picking_enabled, and Slic3r::GUI::plater().

Referenced by _is_xray_view_active(), and _render_objects().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _load_sla_shells()

void Slic3r::GUI::GLCanvas3D::_load_sla_shells ( )

private

{
    const SLAPrint* print = this->sla_print();
    if (print->objects().empty())
        // nothing to render, return
        return;
 
    auto add_volume = [this](const SLAPrintObject &object, int volume_id, const SLAPrintObject::Instance& instance,
        const TriangleMesh& mesh, const ColorRGBA& color, bool outside_printer_detection_enabled) {
        m_volumes.volumes.emplace_back(new GLVolume(color));
        GLVolume& v = *m_volumes.volumes.back();
        v.model.init_from(mesh);
        v.shader_outside_printer_detection_enabled = outside_printer_detection_enabled;
        v.composite_id.volume_id = volume_id;
        v.set_instance_offset(unscale(instance.shift.x(), instance.shift.y(), 0.0));
        v.set_instance_rotation({ 0.0, 0.0, (double)instance.rotation });
        v.set_instance_mirror(X, object.is_left_handed() ? -1. : 1.);
        v.set_convex_hull(mesh.convex_hull_3d());
    };
 
    // adds objects' volumes
    for (const SLAPrintObject* obj : print->objects())
        if (obj->is_step_done(slaposSliceSupports)) {
            unsigned int initial_volumes_count = (unsigned int)m_volumes.volumes.size();
            for (const SLAPrintObject::Instance& instance : obj->instances()) {
                add_volume(*obj, 0, instance, obj->get_mesh_to_print(), GLVolume::MODEL_COLOR[0], true);
                // Set the extruder_id and volume_id to achieve the same color as in the 3D scene when
                // through the update_volumes_colors_by_extruder() call.
                m_volumes.volumes.back()->extruder_id = obj->model_object()->volumes.front()->extruder_id();
                if (obj->is_step_done(slaposSupportTree) && obj->has_mesh(slaposSupportTree))
                    add_volume(*obj, -int(slaposSupportTree), instance, obj->support_mesh(), GLVolume::SLA_SUPPORT_COLOR, true);
                if (obj->is_step_done(slaposPad) && obj->has_mesh(slaposPad))
                    add_volume(*obj, -int(slaposPad), instance, obj->pad_mesh(), GLVolume::SLA_PAD_COLOR, false);
            }
            double shift_z = obj->get_current_elevation();
            for (unsigned int i = initial_volumes_count; i < m_volumes.volumes.size(); ++ i) {
                // apply shift z
                m_volumes.volumes[i]->set_sla_shift_z(shift_z);
            }
        }
 
    update_volumes_colors_by_extruder();
}

Referenced by _load_sla_shells(), and load_sla_preview().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _max_bounding_box()

BoundingBoxf3 Slic3r::GUI::GLCanvas3D::_max_bounding_box	(	bool	include_gizmos,
		bool	include_bed_model,
		bool	include_plates ) const

private

{
    BoundingBoxf3 bb = volumes_bounding_box();
 
    // The following is a workaround for gizmos not being taken in account when calculating the tight camera frustrum
    // A better solution would ask the gizmo manager for the bounding box of the current active gizmo, if any
    if (include_gizmos && m_gizmos.is_running())
    {
        BoundingBoxf3 sel_bb = m_selection.get_bounding_box();
        Vec3d sel_bb_center = sel_bb.center();
        Vec3d extend_by = sel_bb.max_size() * Vec3d::Ones();
        bb.merge(BoundingBoxf3(sel_bb_center - extend_by, sel_bb_center + extend_by));
    }
 
    bb.merge(include_bed_model ? m_bed.extended_bounding_box() : m_bed.build_volume().bounding_volume());
    if (include_plates) {
        bb.merge(wxGetApp().plater()->get_partplate_list().get_bounding_box());
    }
 
    if (!m_main_toolbar.is_enabled()) {
        const BoundingBoxf3& toolpath_bb = m_gcode_viewer.get_max_bounding_box();
        if (toolpath_bb.max_size() > 0.f)
            bb.merge(toolpath_bb);
        else
            bb.merge(m_gcode_viewer.get_shell_bounding_box());
    }
 
    if ((m_canvas_type == CanvasView3D) && (fff_print()->config().print_sequence == PrintSequence::ByObject)) {
        float height_to_lid, height_to_rod;
        wxGetApp().plater()->get_partplate_list().get_height_limits(height_to_lid, height_to_rod);
        bb.max.z() = std::max(bb.max.z(), (double)height_to_lid);
    }
 
    return bb;
}

References Slic3r::ByObject, CanvasView3D, Slic3r::BoundingBox3Base< PointType >::center(), fff_print(), m_bed, m_canvas_type, m_gcode_viewer, m_gizmos, m_main_toolbar, m_selection, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBox3Base< PointType >::max_size(), Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::GUI::plater(), Slic3r::print_sequence(), and volumes_bounding_box().

Referenced by _render_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _mouse_to_3d()

Vec3d Slic3r::GUI::GLCanvas3D::_mouse_to_3d	(	const Point &	mouse_pos,
		float *	z = nullptr )

{
    if (m_canvas == nullptr)
        return Vec3d(DBL_MAX, DBL_MAX, DBL_MAX);
 
    if (z == nullptr) {
        const SceneRaycaster::HitResult hit = m_scene_raycaster.hit(mouse_pos.cast<double>(), wxGetApp().plater()->get_camera(), nullptr);
        return hit.is_valid() ? hit.position.cast<double>() : _mouse_to_bed_3d(mouse_pos);
    }
    else {
        const Camera& camera = wxGetApp().plater()->get_camera();
        const Vec4i32 viewport(camera.get_viewport().data());
        Vec3d out;
        igl::unproject(Vec3d(mouse_pos.x(), viewport[3] - mouse_pos.y(), *z), camera.get_view_matrix().matrix(), camera.get_projection_matrix().matrix(), viewport, out);
        return out;
    }
}

References _mouse_to_3d(), _mouse_to_bed_3d(), camera, get_camera(), Slic3r::GUI::SceneRaycaster::HitResult::is_valid(), m_canvas, m_scene_raycaster, Slic3r::GUI::plater(), and Slic3r::GUI::SceneRaycaster::HitResult::position.

Referenced by _mouse_to_3d(), mouse_ray(), on_mouse(), and on_mouse_wheel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _mouse_to_bed_3d()

Vec3d Slic3r::GUI::GLCanvas3D::_mouse_to_bed_3d ( const Point & mouse_pos )

private

{
    return mouse_ray(mouse_pos).intersect_plane(0.0);
}

References _mouse_to_bed_3d(), and mouse_ray().

Referenced by _mouse_to_3d(), and _mouse_to_bed_3d().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _on_section_view_changed()

void Slic3r::GUI::GLCanvas3D::_on_section_view_changed ( )

private

{
    m_gizmos.update_section_view();
    // Set from the overlay, after this frame's scene was drawn.
    set_as_dirty();
    request_extra_frame();
}

References m_gizmos, request_extra_frame(), and set_as_dirty().

Referenced by align_section_view_to_camera(), and set_section_view_ratio().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _overlay_signature()

size_t Slic3r::GUI::GLCanvas3D::_overlay_signature ( const ImDrawData * draw_data ) const

private

{
    // The recorded ImGui geometry plus the state of the toolbars and the gizmo bar, which draw
    // outside ImGui.
    size_t hash = ImGuiWrapper::draw_data_signature(draw_data);
    for (size_t state_hash : { m_main_toolbar.get_state_hash(), m_separator_toolbar.get_state_hash(),
                               m_assemble_view_toolbar.get_state_hash(),
                               collapse_toolbar().get_state_hash(),
                               m_gizmos.get_overlay_state_hash() })
        boost::hash_combine(hash, state_hash);
    return hash;
}

References _overlay_signature(), collapse_toolbar(), Slic3r::GUI::ImGuiWrapper::draw_data_signature(), m_assemble_view_toolbar, m_gizmos, m_main_toolbar, and m_separator_toolbar.

Referenced by _overlay_signature(), and _render_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _perform_layer_editing_action()

void Slic3r::GUI::GLCanvas3D::_perform_layer_editing_action ( wxMouseEvent * evt = nullptr )

{
    int object_idx_selected = m_layers_editing.last_object_id;
    if (object_idx_selected == -1)
        return;
 
    // A volume is selected. Test, whether hovering over a layer thickness bar.
    if (evt != nullptr) {
        const Rect& rect = LayersEditing::get_bar_rect_screen(*this);
        float b = rect.get_bottom();
        m_layers_editing.last_z = m_layers_editing.object_max_z() * (b - evt->GetY() - 1.0f) / (b - rect.get_top());
        m_layers_editing.last_action =
            evt->ShiftDown() ? (evt->RightIsDown() ? LAYER_HEIGHT_EDIT_ACTION_SMOOTH : LAYER_HEIGHT_EDIT_ACTION_REDUCE) :
            (evt->RightIsDown() ? LAYER_HEIGHT_EDIT_ACTION_INCREASE : LAYER_HEIGHT_EDIT_ACTION_DECREASE);
    }
 
    m_layers_editing.adjust_layer_height_profile();
    _refresh_if_shown_on_screen();
 
    // Automatic action on mouse down with the same coordinate.
    _start_timer();
}

References _perform_layer_editing_action(), _refresh_if_shown_on_screen(), _start_timer(), Slic3r::GUI::GLCanvas3D::LayersEditing::get_bar_rect_screen(), Slic3r::GUI::Rect::get_bottom(), Slic3r::GUI::Rect::get_top(), Slic3r::LAYER_HEIGHT_EDIT_ACTION_DECREASE, Slic3r::LAYER_HEIGHT_EDIT_ACTION_INCREASE, Slic3r::LAYER_HEIGHT_EDIT_ACTION_REDUCE, Slic3r::LAYER_HEIGHT_EDIT_ACTION_SMOOTH, m_layers_editing, and Slic3r::GUI::wxMouseEvent.

Referenced by _perform_layer_editing_action(), on_mouse(), and on_timer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _picking_pass()

void Slic3r::GUI::GLCanvas3D::_picking_pass ( )

private

{
    if (!m_picking_enabled || m_mouse.dragging || m_mouse.position == Vec2d(DBL_MAX, DBL_MAX) || m_gizmos.is_dragging()) {
#if ENABLE_RAYCAST_PICKING_DEBUG
        ImGuiWrapper& imgui = *wxGetApp().imgui();
        imgui.begin(std::string("Hit result"), ImGuiWindowFlags_AlwaysAutoResize);
        imgui.text("Picking disabled");
        imgui.end();
#endif // ENABLE_RAYCAST_PICKING_DEBUG
        return;
    }
 
    m_hover_volume_idxs.clear();
    m_hover_plate_idxs.clear();
 
    // Orca: Picking and camera navigation must interpret the active gizmo clipping plane identically.
    const ClippingPlane clipping_plane = get_raycaster_clipping_plane();
    const SceneRaycaster::HitResult hit = m_scene_raycaster.hit(m_mouse.position, wxGetApp().plater()->get_camera(), &clipping_plane);
    if (hit.is_valid()) {
        switch (hit.type)
        {
        case SceneRaycaster::EType::Volume:
        {
            if (0 <= hit.raycaster_id && hit.raycaster_id < (int)m_volumes.volumes.size()) {
                const GLVolume* volume = m_volumes.volumes[hit.raycaster_id];
                if (volume->is_active && !volume->disabled && (volume->composite_id.volume_id >= 0 || m_render_sla_auxiliaries)) {
                    // do not add the volume id if CTRL is pressed while a gizmo that does not allow Ctrl+click selection is active
                    if (m_gizmos.is_allow_multi_select_parts_or_objects() || !wxGetKeyState(WXK_CONTROL))
                        m_hover_volume_idxs.emplace_back(hit.raycaster_id);
                    m_gizmos.set_hover_id(-1);
                }
            }
            else
                assert(false);
 
            break;
        }
        case SceneRaycaster::EType::Gizmo:
        case SceneRaycaster::EType::FallbackGizmo:
        {
            const Size& cnv_size = get_canvas_size();
            const bool inside = 0 <= m_mouse.position.x() && m_mouse.position.x() < cnv_size.get_width() &&
                0 <= m_mouse.position.y() && m_mouse.position.y() < cnv_size.get_height();
            m_gizmos.set_hover_id(inside ? hit.raycaster_id : -1);
            break;
        }
        case SceneRaycaster::EType::Bed:
        {
            // BBS: add plate picking logic
            int plate_hover_id = hit.raycaster_id;
            if (plate_hover_id >= 0 && plate_hover_id < PartPlateList::MAX_PLATES_COUNT * PartPlate::GRABBER_COUNT) {
                wxGetApp().plater()->get_partplate_list().set_hover_id(plate_hover_id);
                m_hover_plate_idxs.emplace_back(plate_hover_id);
            } else {
                wxGetApp().plater()->get_partplate_list().reset_hover_id();
            }
            m_gizmos.set_hover_id(-1);
            break;
        }
        default:
        {
            assert(false);
            break;
        }
        }
    }
    else
        m_gizmos.set_hover_id(-1);
 
    _update_volumes_hover_state();
 
    // IMEX ghost picking runs unconditionally after the normal pass: ghosts visually
    // occlude the main volumes, so their tooltip/click handling must fire even when a
    // regular volume hit also occurred underneath.
    _picking_pass_imex_ghosts();
 
#if ENABLE_RAYCAST_PICKING_DEBUG
    ImGuiWrapper& imgui = *wxGetApp().imgui();
    imgui.begin(std::string("Hit result"), ImGuiWindowFlags_AlwaysAutoResize);
    std::string object_type = "None";
    switch (hit.type)
    {
    case SceneRaycaster::EType::Bed:   { object_type = "Bed"; break; }
    case SceneRaycaster::EType::Gizmo: { object_type = "Gizmo element"; break; }
    case SceneRaycaster::EType::FallbackGizmo: { object_type = "Gizmo2 element"; break; }
    case SceneRaycaster::EType::Volume:
    {
        if (m_volumes.volumes[hit.raycaster_id]->is_wipe_tower)
            object_type = "Volume (Wipe tower)";
        else if (m_volumes.volumes[hit.raycaster_id]->volume_idx() == -int(slaposPad))
            object_type = "Volume (SLA pad)";
        else if (m_volumes.volumes[hit.raycaster_id]->volume_idx() == -int(slaposSupportTree))
            object_type = "Volume (SLA supports)";
        else if (m_volumes.volumes[hit.raycaster_id]->is_modifier)
            object_type = "Volume (Modifier)";
        else
            object_type = "Volume (Part)";
        break;
    }
    default: { break; }
    }
 
    auto add_strings_row_to_table = [&imgui](const std::string& col_1, const ImVec4& col_1_color, const std::string& col_2, const ImVec4& col_2_color,
        const std::string& col_3 = "", const ImVec4& col_3_color = ImGui::GetStyleColorVec4(ImGuiCol_Text)) {
        ImGui::TableNextRow();
        ImGui::TableSetColumnIndex(0);
        imgui.text_colored(col_1_color, col_1.c_str());
        ImGui::TableSetColumnIndex(1);
        imgui.text_colored(col_2_color, col_2.c_str());
        if (!col_3.empty()) {
            ImGui::TableSetColumnIndex(2);
            imgui.text_colored(col_3_color, col_3.c_str());
        }
    };
 
    char buf[1024];
    if (hit.type != SceneRaycaster::EType::None) {
        if (ImGui::BeginTable("Hit", 2)) {
            add_strings_row_to_table("Object ID", ImGuiWrapper::COL_ORANGE_LIGHT, std::to_string(hit.raycaster_id), ImGui::GetStyleColorVec4(ImGuiCol_Text));
            add_strings_row_to_table("Type", ImGuiWrapper::COL_ORANGE_LIGHT, object_type, ImGui::GetStyleColorVec4(ImGuiCol_Text));
            sprintf(buf, "%.3f, %.3f, %.3f", hit.position.x(), hit.position.y(), hit.position.z());
            add_strings_row_to_table("Position", ImGuiWrapper::COL_ORANGE_LIGHT, std::string(buf), ImGui::GetStyleColorVec4(ImGuiCol_Text));
            sprintf(buf, "%.3f, %.3f, %.3f", hit.normal.x(), hit.normal.y(), hit.normal.z());
            add_strings_row_to_table("Normal", ImGuiWrapper::COL_ORANGE_LIGHT, std::string(buf), ImGui::GetStyleColorVec4(ImGuiCol_Text));
            ImGui::EndTable();
        }
    }
    else
        imgui.text("NO HIT");
 
    ImGui::Separator();
    imgui.text("Registered for picking:");
    if (ImGui::BeginTable("Raycasters", 2)) {
        sprintf(buf, "%d (%d)", (int)m_scene_raycaster.beds_count(), (int)m_scene_raycaster.active_beds_count());
        add_strings_row_to_table("Beds", ImGuiWrapper::COL_ORANGE_LIGHT, std::string(buf), ImGui::GetStyleColorVec4(ImGuiCol_Text));
        sprintf(buf, "%d (%d)", (int)m_scene_raycaster.volumes_count(), (int)m_scene_raycaster.active_volumes_count());
        add_strings_row_to_table("Volumes", ImGuiWrapper::COL_ORANGE_LIGHT, std::string(buf), ImGui::GetStyleColorVec4(ImGuiCol_Text));
        sprintf(buf, "%d (%d)", (int)m_scene_raycaster.gizmos_count(), (int)m_scene_raycaster.active_gizmos_count());
        add_strings_row_to_table("Gizmo elements", ImGuiWrapper::COL_ORANGE_LIGHT, std::string(buf), ImGui::GetStyleColorVec4(ImGuiCol_Text));
        sprintf(buf, "%d (%d)", (int)m_scene_raycaster.fallback_gizmos_count(), (int)m_scene_raycaster.active_fallback_gizmos_count());
        add_strings_row_to_table("Gizmo2 elements", ImGuiWrapper::COL_ORANGE_LIGHT, std::string(buf), ImGui::GetStyleColorVec4(ImGuiCol_Text));
        ImGui::EndTable();
    }
 
    std::vector<std::shared_ptr<SceneRaycasterItem>>* gizmo_raycasters = m_scene_raycaster.get_raycasters(SceneRaycaster::EType::Gizmo);
    if (gizmo_raycasters != nullptr && !gizmo_raycasters->empty()) {
        ImGui::Separator();
        imgui.text("Gizmo raycasters IDs:");
        if (ImGui::BeginTable("GizmoRaycasters", 3)) {
            for (size_t i = 0; i < gizmo_raycasters->size(); ++i) {
                add_strings_row_to_table(std::to_string(i), ImGuiWrapper::COL_ORANGE_LIGHT,
                    std::to_string(SceneRaycaster::decode_id(SceneRaycaster::EType::Gizmo, (*gizmo_raycasters)[i]->get_id())), ImGui::GetStyleColorVec4(ImGuiCol_Text),
                    to_string(Geometry::Transformation((*gizmo_raycasters)[i]->get_transform()).get_offset()), ImGui::GetStyleColorVec4(ImGuiCol_Text));
            }
            ImGui::EndTable();
        }
    }
 
    std::vector<std::shared_ptr<SceneRaycasterItem>>* gizmo2_raycasters = m_scene_raycaster.get_raycasters(SceneRaycaster::EType::FallbackGizmo);
    if (gizmo2_raycasters != nullptr && !gizmo2_raycasters->empty()) {
        ImGui::Separator();
        imgui.text("Gizmo2 raycasters IDs:");
        if (ImGui::BeginTable("Gizmo2Raycasters", 3)) {
            for (size_t i = 0; i < gizmo2_raycasters->size(); ++i) {
                add_strings_row_to_table(std::to_string(i), ImGuiWrapper::COL_ORANGE_LIGHT,
                    std::to_string(SceneRaycaster::decode_id(SceneRaycaster::EType::FallbackGizmo, (*gizmo2_raycasters)[i]->get_id())), ImGui::GetStyleColorVec4(ImGuiCol_Text),
                    to_string(Geometry::Transformation((*gizmo2_raycasters)[i]->get_transform()).get_offset()), ImGui::GetStyleColorVec4(ImGuiCol_Text));
            }
            ImGui::EndTable();
        }
    }
 
    imgui.end();
#endif // ENABLE_RAYCAST_PICKING_DEBUG
}

Referenced by _render_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _picking_pass_imex_ghosts()

void Slic3r::GUI::GLCanvas3D::_picking_pass_imex_ghosts ( )

private

{
    m_hover_ghost_head  = -1;
    m_hover_ghost_plate = -1;
 
    if (!m_picking_enabled || m_mouse.dragging || m_mouse.position == Vec2d(DBL_MAX, DBL_MAX) || m_gizmos.is_dragging())
        return;
 
    // Build a world-space ray from the mouse: mouse_ray(pos) returns the near/far
    // world-space points, so direction is b - a.
    const Linef3 ray = mouse_ray(Point(static_cast<coord_t>(m_mouse.position.x()),
                                       static_cast<coord_t>(m_mouse.position.y())));
    const Vec3d ray_origin = ray.a;
    const Vec3d ray_dir    = ray.b - ray.a;
    if (ray_dir.squaredNorm() == 0.0)
        return;
 
    // Standard slab ray-vs-AABB test. Accept a hit when the nearest plane entry is
    // closer than the farthest plane exit and the exit is in front of the origin.
    auto ray_hits_bbox = [](const Vec3d& o, const Vec3d& d, const BoundingBoxf3& bb) -> bool {
        double tmin = -std::numeric_limits<double>::infinity();
        double tmax =  std::numeric_limits<double>::infinity();
        for (int i = 0; i < 3; ++i) {
            if (std::abs(d[i]) < 1e-12) {
                if (o[i] < bb.min[i] || o[i] > bb.max[i])
                    return false;
            }
            else {
                double t1 = (bb.min[i] - o[i]) / d[i];
                double t2 = (bb.max[i] - o[i]) / d[i];
                if (t1 > t2) std::swap(t1, t2);
                tmin = std::max(tmin, t1);
                tmax = std::min(tmax, t2);
                if (tmin > tmax) return false;
            }
        }
        return tmax >= 0.0;
    };
 
    // Match _render_imex_ghosts: only hit-test ghosts on the active plate. Picking
    // through ghosts on background plates would hand the user a stale plate index
    // for the head-filament popover and let them edit a plate they aren't looking at.
    PartPlateList& ppl = wxGetApp().plater()->get_partplate_list();
    PartPlate* active_plate = ppl.get_curr_plate();
    if (active_plate) {
        const auto& ghosts = active_plate->get_imex_ghost_volumes();
        for (const auto& g : ghosts) {
            if (!g || !g->is_active || !g->picking) continue;
            const BoundingBoxf3 bbox = g->transformed_bounding_box();
            if (ray_hits_bbox(ray_origin, ray_dir, bbox)) {
                m_hover_ghost_head  = PartPlate::imex_ghost_head_from_composite_id(g->composite_id.object_id);
                m_hover_ghost_plate = ppl.get_curr_plate_index();
                return;  // first hit wins
            }
        }
    }
}

References Slic3r::Linef3::a, Slic3r::Linef3::b, Slic3r::GUI::PartPlateList::get_curr_plate(), Slic3r::GUI::PartPlateList::get_curr_plate_index(), Slic3r::GUI::PartPlate::get_imex_ghost_volumes(), Slic3r::GUI::PartPlate::imex_ghost_head_from_composite_id(), m_gizmos, m_hover_ghost_head, m_hover_ghost_plate, m_mouse, m_picking_enabled, and mouse_ray().

Referenced by _picking_pass().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _rectangular_selection_picking_pass()

void Slic3r::GUI::GLCanvas3D::_rectangular_selection_picking_pass ( )

private

{
    m_gizmos.set_hover_id(-1);
 
    std::set<int> idxs;
 
    if (m_picking_enabled) {
        const size_t width  = std::max<size_t>(m_rectangle_selection.get_width(), 1);
        const size_t height = std::max<size_t>(m_rectangle_selection.get_height(), 1);
 
        const OpenGLManager::EFramebufferType framebuffers_type = OpenGLManager::get_framebuffers_type();
        bool use_framebuffer = framebuffers_type != OpenGLManager::EFramebufferType::Unknown;
 
        GLuint render_fbo = 0;
        GLuint render_tex = 0;
        GLuint render_depth = 0;
        if (use_framebuffer) {
            // setup a framebuffer which covers only the selection rectangle
            if (framebuffers_type == OpenGLManager::EFramebufferType::Arb) {
                glsafe(::glGenFramebuffers(1, &render_fbo));
                glsafe(::glBindFramebuffer(GL_FRAMEBUFFER, render_fbo));
            }
            else {
                glsafe(::glGenFramebuffersEXT(1, &render_fbo));
                glsafe(::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, render_fbo));
            }
            glsafe(::glGenTextures(1, &render_tex));
            glsafe(::glBindTexture(GL_TEXTURE_2D, render_tex));
            glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr));
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
            if (framebuffers_type == OpenGLManager::EFramebufferType::Arb) {
                glsafe(::glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, render_tex, 0));
                glsafe(::glGenRenderbuffers(1, &render_depth));
                glsafe(::glBindRenderbuffer(GL_RENDERBUFFER, render_depth));
                glsafe(::glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height));
                glsafe(::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, render_depth));
            }
            else {
                glsafe(::glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, render_tex, 0));
                glsafe(::glGenRenderbuffersEXT(1, &render_depth));
                glsafe(::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, render_depth));
                glsafe(::glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height));
                glsafe(::glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, render_depth));
            }
            const GLenum drawBufs[] = { GL_COLOR_ATTACHMENT0 };
            glsafe(::glDrawBuffers(1, drawBufs));
            if (framebuffers_type == OpenGLManager::EFramebufferType::Arb) {
                if (::glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
                    use_framebuffer = false;
            }
            else {
                if (::glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT)
                    use_framebuffer = false;
            }
        }
 
        if (m_multisample_allowed)
          // This flag is often ignored by NVIDIA drivers if rendering into a screen buffer.
            glsafe(::glDisable(GL_MULTISAMPLE));
 
        glsafe(::glDisable(GL_BLEND));
        glsafe(::glEnable(GL_DEPTH_TEST));
 
        glsafe(::glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
 
        Camera& main_camera = wxGetApp().plater()->get_camera();
        Camera framebuffer_camera;
        Camera* camera = &main_camera;
        if (use_framebuffer) {
            // setup a camera which covers only the selection rectangle
            const std::array<int, 4>& viewport = camera->get_viewport();
            const double near_left   = camera->get_near_left();
            const double near_bottom = camera->get_near_bottom();
            const double near_width  = camera->get_near_width();
            const double near_height = camera->get_near_height();
 
            const double ratio_x = near_width / double(viewport[2]);
            const double ratio_y = near_height / double(viewport[3]);
 
            const double rect_near_left   = near_left + double(m_rectangle_selection.get_left()) * ratio_x;
            const double rect_near_bottom = near_bottom + (double(viewport[3]) - double(m_rectangle_selection.get_bottom())) * ratio_y;
            double rect_near_right = near_left + double(m_rectangle_selection.get_right()) * ratio_x;
            double rect_near_top   = near_bottom + (double(viewport[3]) - double(m_rectangle_selection.get_top())) * ratio_y;
 
            if (rect_near_left == rect_near_right)
                rect_near_right = rect_near_left + ratio_x;
            if (rect_near_bottom == rect_near_top)
                rect_near_top = rect_near_bottom + ratio_y;
 
            framebuffer_camera.look_at(camera->get_position(), camera->get_target(), camera->get_dir_up());
            framebuffer_camera.set_type(camera->get_type());
            framebuffer_camera.apply_projection(rect_near_left, rect_near_right, rect_near_bottom, rect_near_top, camera->get_near_z(), camera->get_far_z());
            framebuffer_camera.set_viewport(0, 0, width, height);
            framebuffer_camera.apply_viewport();
            camera = &framebuffer_camera;
        }
 
        _render_volumes_for_picking(*camera);
        //BBS: remove the bed picking logic
        //_render_bed_for_picking(!wxGetApp().plater()->get_camera().is_looking_downward());
 
        if (m_multisample_allowed)
            glsafe(::glEnable(GL_MULTISAMPLE));
 
        const size_t px_count = width * height;
 
        const size_t left = use_framebuffer ? 0 : (size_t)m_rectangle_selection.get_left();
        const size_t top  = use_framebuffer ? 0 : (size_t)get_canvas_size().get_height() - (size_t)m_rectangle_selection.get_top();
#define USE_PARALLEL 1
#if USE_PARALLEL
            struct Pixel
            {
                std::array<GLubyte, 4> data;
              // Only non-interpolated colors are valid, those have their lowest three bits zeroed.
                bool valid() const { return picking_checksum_alpha_channel(data[0], data[1], data[2]) == data[3]; }
                // we reserve color = (0,0,0) for occluders (as the printbed)
                // volumes' id are shifted by 1
                // see: _render_volumes_for_picking()
                //BBS: remove the bed picking logic
                int id() const { return data[0] + (data[1] << 8) + (data[2] << 16); }
                //int id() const { return data[0] + (data[1] << 8) + (data[2] << 16) - 1; }
            };
 
            std::vector<Pixel> frame(px_count);
            glsafe(::glReadPixels(left, top, width, height, GL_RGBA, GL_UNSIGNED_BYTE, (void*)frame.data()));
 
            tbb::spin_mutex mutex;
            tbb::parallel_for(tbb::blocked_range<size_t>(0, frame.size(), (size_t)width),
                [this, &frame, &idxs, &mutex](const tbb::blocked_range<size_t>& range) {
                for (size_t i = range.begin(); i < range.end(); ++i)
                  if (frame[i].valid()) {
                      int volume_id = frame[i].id();
                      if (0 <= volume_id && volume_id < (int)m_volumes.volumes.size()) {
                          mutex.lock();
                          idxs.insert(volume_id);
                          mutex.unlock();
                      }
                  }
            });
#else
            std::vector<GLubyte> frame(4 * px_count);
            glsafe(::glReadPixels(left, top, width, height, GL_RGBA, GL_UNSIGNED_BYTE, (void*)frame.data()));
 
            for (int i = 0; i < px_count; ++i)
            {
                int px_id = 4 * i;
                int volume_id = frame[px_id] + (frame[px_id + 1] << 8) + (frame[px_id + 2] << 16);
                if (0 <= volume_id && volume_id < (int)m_volumes.volumes.size())
                    idxs.insert(volume_id);
            }
#endif // USE_PARALLEL
            if (camera != &main_camera)
                main_camera.apply_viewport();
 
            if (framebuffers_type == OpenGLManager::EFramebufferType::Arb) {
                glsafe(::glBindFramebuffer(GL_FRAMEBUFFER, 0));
                if (render_depth != 0)
                    glsafe(::glDeleteRenderbuffers(1, &render_depth));
                if (render_fbo != 0)
                    glsafe(::glDeleteFramebuffers(1, &render_fbo));
            }
            else if (framebuffers_type == OpenGLManager::EFramebufferType::Ext) {
                glsafe(::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
                if (render_depth != 0)
                    glsafe(::glDeleteRenderbuffersEXT(1, &render_depth));
                if (render_fbo != 0)
                    glsafe(::glDeleteFramebuffersEXT(1, &render_fbo));
            }
 
            if (render_tex != 0)
                glsafe(::glDeleteTextures(1, &render_tex));
    }
 
    m_hover_volume_idxs.assign(idxs.begin(), idxs.end());
    _update_volumes_hover_state();
}

References _render_volumes_for_picking(), Slic3r::GUI::Camera::apply_projection(), Slic3r::GUI::Camera::apply_viewport(), Slic3r::GUI::OpenGLManager::Arb, camera, Slic3r::GUI::OpenGLManager::Ext, get_canvas_size(), Slic3r::GUI::OpenGLManager::get_framebuffers_type(), Slic3r::GUI::Size::get_height(), GL_BLEND, GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_BUFFER_BIT, GL_DEPTH_ATTACHMENT, GL_DEPTH_ATTACHMENT_EXT, GL_DEPTH_BUFFER_BIT, GL_DEPTH_COMPONENT, GL_DEPTH_TEST, GL_FRAMEBUFFER, GL_FRAMEBUFFER_COMPLETE, GL_FRAMEBUFFER_COMPLETE_EXT, GL_FRAMEBUFFER_EXT, GL_MULTISAMPLE, GL_NEAREST, GL_RENDERBUFFER, GL_RENDERBUFFER_EXT, GL_RGBA, GL_RGBA8, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_UNSIGNED_BYTE, glBindFramebuffer, glBindFramebufferEXT, glBindRenderbuffer, glBindRenderbufferEXT, glBindTexture, glCheckFramebufferStatus, glCheckFramebufferStatusEXT, glClear, glDeleteFramebuffers, glDeleteFramebuffersEXT, glDeleteRenderbuffers, glDeleteRenderbuffersEXT, glDeleteTextures, glDisable, glDrawBuffers, glEnable, glFramebufferRenderbuffer, glFramebufferRenderbufferEXT, glFramebufferTexture2D, glFramebufferTexture2DEXT, glGenFramebuffers, glGenFramebuffersEXT, glGenRenderbuffers, glGenRenderbuffersEXT, glGenTextures, glReadPixels, glRenderbufferStorage, glRenderbufferStorageEXT, glsafe, glTexImage2D, glTexParameteri, Slic3r::GUI::Camera::look_at(), m_gizmos, m_multisample_allowed, m_picking_enabled, m_rectangle_selection, m_volumes, Slic3r::picking_checksum_alpha_channel(), Slic3r::range(), Slic3r::GUI::Camera::set_type(), Slic3r::GUI::Camera::set_viewport(), and Slic3r::GUI::OpenGLManager::Unknown.

Referenced by _render_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _refresh_if_shown_on_screen()

void Slic3r::GUI::GLCanvas3D::_refresh_if_shown_on_screen ( bool scene_dirty = true )

private

{
    if (_is_shown_on_screen()) {
        const Size& cnv_size = get_canvas_size();
        _resize((unsigned int)cnv_size.get_width(), (unsigned int)cnv_size.get_height());
 
        // Because of performance problems on macOS, where PaintEvents are not delivered
        // frequently enough, we render here directly when we can.
        _render_frame(scene_dirty);
    }
}

References _is_shown_on_screen(), _render_frame(), _resize(), get_canvas_size(), Slic3r::GUI::Size::get_height(), and Slic3r::GUI::Size::get_width().

Referenced by _perform_layer_editing_action(), on_idle(), on_mouse(), on_paint(), on_set_focus(), and update_ui_from_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_3d_navigator()

void Slic3r::GUI::GLCanvas3D::_render_3d_navigator ( )

private

{
    if (!wxGetApp().show_3d_navigator()) {
        m_canvas_toolbar_pos[0] = 0;
        m_navigator_dragging = false;
        return;
    }
 
    // Fix stealing capture event from other drag events
    const bool other_drag_active = !m_navigator_dragging && (m_moving || m_rectangle_selection.is_dragging() || m_gizmos.is_dragging() || m_layers_editing.state == LayersEditing::Editing);
 
    ImGuiIO& io = ImGui::GetIO();
    const bool saved_mouse_down0 = io.MouseDown[0];
    if (other_drag_active)
        io.MouseDown[0] = false;
 
    ImGuizmo::BeginFrame();
 
    auto& style                                = ImGuizmo::GetStyle();
    style.Colors[ImGuizmo::COLOR::DIRECTION_X] = ImGuiWrapper::to_ImVec4(ColorRGBA::Y());
    style.Colors[ImGuizmo::COLOR::DIRECTION_Y] = ImGuiWrapper::to_ImVec4(ColorRGBA::Z());
    style.Colors[ImGuizmo::COLOR::DIRECTION_Z] = ImGuiWrapper::to_ImVec4(ColorRGBA::X());
    style.Colors[ImGuizmo::COLOR::TEXT] = m_is_dark ? ImVec4(224 / 255.f, 224 / 255.f, 224 / 255.f, 1.f) : ImVec4(.2f, .2f, .2f, 1.0f);
    style.Colors[ImGuizmo::COLOR::FACE]        = m_is_dark ? ImVec4(0.23f, 0.23f, 0.23f, 1.f) : ImVec4(0.77f, 0.77f, 0.77f, 1);
    strcpy(style.AxisLabels[ImGuizmo::Axis::Axis_X], _u8L_CONTEXT("Y", "Axis").c_str()); // ORCA use uppercase to match text on tranform widgets
    strcpy(style.AxisLabels[ImGuizmo::Axis::Axis_Y], _u8L_CONTEXT("Z", "Axis").c_str()); // ORCA use uppercase to match text on tranform widgets
    strcpy(style.AxisLabels[ImGuizmo::Axis::Axis_Z], _u8L_CONTEXT("X", "Axis").c_str()); // ORCA use uppercase to match text on tranform widgets
    strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_FRONT], _u8L_CONTEXT("Front", "Camera View").c_str());
    strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_BACK], _u8L_CONTEXT("Back", "Camera View").c_str());
    strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_TOP], _u8L_CONTEXT("Top", "Camera View").c_str());
    strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_BOTTOM], _u8L_CONTEXT("Bottom", "Camera View").c_str());
    strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_LEFT], _u8L_CONTEXT("Left", "Camera View").c_str());
    strcpy(style.FaceLabels[ImGuizmo::FACES::FACE_RIGHT], _u8L_CONTEXT("Right", "Camera View").c_str());
 
    float sc = get_scale();
#ifdef WIN32
    const int dpi = get_dpi_for_window(wxGetApp().GetTopWindow());
    sc *= (float) dpi / (float) DPI_DEFAULT;
#endif // WIN32
 
    const float viewManipulateLeft = 0;
    const float viewManipulateTop  = io.DisplaySize.y;
    const float camDistance        = 8.f;
 
    Camera&     camera           = wxGetApp().plater()->get_camera();
    Transform3d m                = Transform3d::Identity();
    m.matrix().block(0, 0, 3, 3) = camera.get_view_rotation().toRotationMatrix();
    // Rotate along X and Z axis for 90 degrees to have Y-up
    const auto coord_mapping_transform = Geometry::rotation_transform(Vec3d(0.5 * PI, 0, 0.5 * PI));
    m = m * coord_mapping_transform;
    float cameraView[16];
    for (unsigned int c = 0; c < 4; ++c) {
        for (unsigned int r = 0; r < 4; ++r) {
            cameraView[c * 4 + r] = m(r, c);
        }
    }
 
    const float size  = NAVIGATOR_SIZE * sc;
    m_canvas_toolbar_pos[0] = size;
    const auto result = ImGuizmo::ViewManipulate(cameraView, cameraProjection, ImGuizmo::OPERATION::ROTATE, ImGuizmo::MODE::WORLD, nullptr,
                                                 camDistance, ImVec2(viewManipulateLeft, viewManipulateTop - size), ImVec2(size, size),
                                                 0x00101010);
 
    // Restore the real mouse-down state
    if (other_drag_active)
        io.MouseDown[0] = saved_mouse_down0;
 
    if (result.changed) {
        for (unsigned int c = 0; c < 4; ++c) {
            for (unsigned int r = 0; r < 4; ++r) {
                m(r, c) = cameraView[c * 4 + r];
            }
        }
        // Rotate back
        m = m * (coord_mapping_transform.inverse());
        camera.set_rotation(m);
 
        if (result.dragging) {
            // Switch back to perspective view when normal dragging
            camera.auto_type(Camera::EType::Perspective);
        } else if (result.clicked_box >= 0) {
            switch (result.clicked_box) {
            case 4: // back
            case 10: // top
            case 12: // right
            case 14: // left
            case 16: // bottom
            case 22: // front
                // Automatically switch to orthographic view when click the center face of the navigator
                camera.auto_type(Camera::EType::Ortho); break;
            default:
                // Otherwise switch back to perspective view
                camera.auto_type(Camera::EType::Perspective); break;
            }
        }
 
        request_extra_frame();
    }
 
    m_navigator_dragging = result.dragging;
}

References _u8L_CONTEXT, camera, Slic3r::GUI::cameraProjection, Slic3r::GUI::DPI_DEFAULT, Slic3r::GUI::GLCanvas3D::LayersEditing::Editing, Slic3r::GUI::get_dpi_for_window(), get_scale(), m_canvas_toolbar_pos, m_gizmos, m_is_dark, m_layers_editing, m_moving, m_navigator_dragging, m_rectangle_selection, Slic3r::GUI::NAVIGATOR_SIZE, Slic3r::GUI::Camera::Ortho, Slic3r::GUI::Camera::Perspective, PI, request_extra_frame(), Slic3r::Geometry::rotation_transform(), style, Slic3r::GUI::ImGuiWrapper::to_ImVec4(), Slic3r::ColorRGBA::X(), Slic3r::ColorRGBA::Y(), and Slic3r::ColorRGBA::Z().

Referenced by _render_overlays().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_arrange_menu()

void Slic3r::GUI::GLCanvas3D::_render_arrange_menu	(	float	left,
		float	right,
		float	bottom,
		float	top )

private

{
    ImGuiWrapper *imgui = wxGetApp().imgui();
 
    auto canvas_w = float(get_canvas_size().get_width());
    auto canvas_h = float(get_canvas_size().get_height());
    //BBS: GUI refactor: move main toolbar to the right
    //original use center as {0.0}, and top is (canvas_h/2), bottom is (-canvas_h/2), also plus inv_camera
    //now change to left_up as {0,0}, and top is 0, bottom is canvas_h
#if BBS_TOOLBAR_ON_TOP
    float left_pos = m_main_toolbar.get_item("arrange")->render_left_pos;
    const float x = (1 + left_pos) * canvas_w / 2;
    imgui->set_next_window_pos(x, m_main_toolbar.get_height(), ImGuiCond_Always, 0.0f, 0.0f);
 
#else
    const float x = canvas_w - m_main_toolbar.get_width();
    const float y = 0.5f * canvas_h - top * float(wxGetApp().plater()->get_camera().get_zoom());
    imgui->set_next_window_pos(x, y, ImGuiCond_Always, 1.0f, 0.0f);
#endif
 
    //BBS
    ImGuiWrapper::push_toolbar_style(get_scale());
 
    imgui->begin(_L("Arrange options"), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar);
 
    ArrangeSettings &settings_out = get_arrange_settings();
    const float slider_icon_width = imgui->get_slider_icon_size().x;
    const float cursor_slider_left = imgui->calc_text_size(_L("Spacing")).x + imgui->scaled(1.5f);
    const float minimal_slider_width = imgui->scaled(4.f);
    float window_width  = minimal_slider_width + 2 * slider_icon_width;
    auto &appcfg = wxGetApp().app_config;
    PrinterTechnology ptech = current_printer_technology();
 
    std::string dist_key = "min_object_distance", rot_key = "enable_rotation";
    std::string multi_material_key = "allow_multi_materials_on_same_plate";
    std::string avoid_extrusion_key = "avoid_extrusion_cali_region";
    std::string postfix;
    //BBS:
    bool seq_print = false;
 
    if (ptech == ptSLA) {
        postfix      = "_sla";
    } else if (ptech == ptFFF) {
        seq_print    = wxGetApp().global_print_sequence() == PrintSequence::ByObject;
        postfix      = seq_print ? "_fff_seq_print" : "_fff";
    }
 
    dist_key += postfix;
    rot_key  += postfix;
 
    ImGui::AlignTextToFramePadding();
    imgui->text(_L("Spacing"));
    ImGui::SameLine(1.2 * cursor_slider_left);
    ImGui::PushItemWidth(window_width - slider_icon_width);
    bool b_Spacing = imgui->bbl_slider_float_style("##Spacing", &settings_out.distance, 0.f, 100.0f, "%5.2f", 1.0f, /*clamp=*/false);
    ImGui::SameLine(window_width - slider_icon_width + 1.3 * cursor_slider_left);
    ImGui::PushItemWidth(1.5 * slider_icon_width);
    bool b_spacing_input = ImGui::BBLDragFloat("##spacing_input", &settings_out.distance, 0.05f, 0.0f, 0.0f, "%.2f");
    if (b_Spacing || b_spacing_input) {
        settings_out.distance = std::max(0.f, settings_out.distance);
        appcfg->set("arrange", dist_key.c_str(), float_to_string_decimal_point(settings_out.distance));
    }
    imgui->text(_L("0 means auto spacing."));
 
    ImGui::Separator();
    if (imgui->bbl_checkbox(_L("Auto rotate for arrangement"), settings_out.enable_rotation))
        appcfg->set("arrange", rot_key.c_str(), settings_out.enable_rotation);
 
    if (imgui->bbl_checkbox(_L("Allow multiple materials on same plate"), settings_out.allow_multi_materials_on_same_plate))
        appcfg->set("arrange", multi_material_key.c_str(), settings_out.allow_multi_materials_on_same_plate);
 
    // only show this option if the printer has micro Lidar and can do first layer scan
    DynamicPrintConfig &current_config = wxGetApp().preset_bundle->printers.get_edited_preset().config;
    const bool has_lidar = wxGetApp().preset_bundle->is_bbl_vendor();
    auto                op             = current_config.option("scan_first_layer");
    if (has_lidar && op && op->getBool()) {
        if (imgui->bbl_checkbox(_L("Avoid extrusion calibration region"), settings_out.avoid_extrusion_cali_region))
            appcfg->set("arrange", avoid_extrusion_key.c_str(), settings_out.avoid_extrusion_cali_region);
    } else {
        settings_out.avoid_extrusion_cali_region = false;
    }
 
    // Align to Y axis. Only enable this option when auto rotation not enabled
    {
        if (settings_out.enable_rotation) {  // do not allow align to Y axis if rotation is enabled
            imgui->disabled_begin(true);
            settings_out.align_to_y_axis = false;
        }
 
        imgui->bbl_checkbox(_L("Align to Y axis"), settings_out.align_to_y_axis);
 
        if (settings_out.enable_rotation == true) { imgui->disabled_end(); }
    }
 
    ImGui::Separator();
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(15.0f, 10.0f));
    if (imgui->button(_L("Arrange"))) {
        wxGetApp().plater()->set_prepare_state(Job::PREPARE_STATE_DEFAULT);
        wxGetApp().plater()->arrange();
    }
 
    ImGui::SameLine();
 
    if (imgui->button(_L("Reset"))) {
        settings_out = ArrangeSettings{};
        //BBS: add specific arrange settings
        if (seq_print) settings_out.is_seq_print = true;
 
        if (auto printer_structure_opt = wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionEnum<PrinterStructure>>("printer_structure")) {
            settings_out.align_to_y_axis = (printer_structure_opt->value == PrinterStructure::psI3);
        }
        else
            settings_out.align_to_y_axis = false;
 
        appcfg->erase("arrange", dist_key);
        appcfg->erase("arrange", rot_key);
        appcfg->erase("arrange", multi_material_key);
        appcfg->erase("arrange", avoid_extrusion_key);
    }
    ImGui::PopStyleVar(1);
    imgui->end();
 
    //BBS
    ImGuiWrapper::pop_toolbar_style();
}

Referenced by _init_main_toolbar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_assemble_control()

void Slic3r::GUI::GLCanvas3D::_render_assemble_control ( )

private

{
    if (m_canvas_type != ECanvasType::CanvasAssembleView) {
        GLVolume::explosion_ratio = m_explosion_ratio = 1.0;
        return;
    }
    if (m_gizmos.get_current_type() == GLGizmosManager::EType::MmSegmentation)
        return;
 
    ImGuiWrapper* imgui = wxGetApp().imgui();
 
    ImGuiWrapper::push_toolbar_style(get_scale());
 
    auto canvas_w = float(get_canvas_size().get_width());
    auto canvas_h = float(get_canvas_size().get_height());
 
    const float text_padding = 7.0f;
    const float slider_width = 60.0f;
    const float value_size = imgui->calc_text_size("3.00"sv).x + text_padding * 2;
    const float item_spacing = imgui->get_item_spacing().x;
    ImVec2 window_padding = ImGui::GetStyle().WindowPadding;
 
    imgui->set_next_window_pos(canvas_w / 2, canvas_h - 10.0f * get_scale(), ImGuiCond_Always, 0.5f, 1.0f);
    imgui->begin(_L("Assembly Control"), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar);
 
    ImGui::AlignTextToFramePadding();
    float tooltip_button_width;
    {
        tooltip_button_width = _render_assembly_tooltip_button(imgui);
    }
    float same_line_width = tooltip_button_width;
    {
        auto temp_x = imgui->calc_text_size(_L("Explosion Ratio")).x;
        ImGui::SameLine(same_line_width);
        ImGui::PushItemWidth(temp_x);
        imgui->text(_L("Explosion Ratio"));
 
        same_line_width +=   (temp_x + item_spacing);
        ImGui::SameLine(same_line_width);
        ImGui::PushItemWidth(slider_width);
        bool explosion_slider_changed = imgui->bbl_slider_float_style("##ratio_slider", &m_explosion_ratio, 1.0f, 3.0f, "%1.2f");
 
        same_line_width +=  (slider_width + item_spacing);
        ImGui::SameLine(same_line_width);
        ImGui::PushItemWidth(value_size);
        bool explosion_input_changed = ImGui::BBLDragFloat("##ratio_input", &m_explosion_ratio, 0.1f, 1.0f, 3.0f, "%1.2f");
        same_line_width    +=   (value_size + item_spacing*2);
    }
    {
        ImGui::SameLine(same_line_width);
        // input
        std::vector<std::string> modes = {_u8L("Object"), _u8L("Part")};
        int selection_idx = m_selection.get_volume_selection_mode() == Selection::Instance ? 0 : 1;
        auto label         = _u8L("Selection Mode") + ":" ;
        auto label_width   = imgui->calc_text_size(label).x ;
        auto item_width    = imgui->calc_text_size(_u8L("Object")).x * 2.5 + imgui->calc_text_size("xx"sv).x+ item_spacing;
        //render imgui
        ImGui::AlignTextToFramePadding();
        ImGui::PushItemWidth(label_width);
        imgui->text(label);
        same_line_width += (label_width + item_spacing);
        ImGui::SameLine(same_line_width);
        ImGui::PushItemWidth(item_width);
        size_t selection_out = selection_idx;
        const char *selected_str = (selection_idx >= 0 && selection_idx < int(modes.size())) ? modes[selection_idx].c_str() : "";
        ImGuiWrapper::push_combo_style(get_scale());
        if (ImGui::BBLBeginCombo(("##" + label).c_str(), selected_str, 0)) {
            for (size_t line_idx = 0; line_idx < modes.size(); ++line_idx) {
                ImGui::PushID(int(line_idx));
                if (ImGui::Selectable("", line_idx == selection_idx))
                    selection_out = line_idx;
 
                ImGui::SameLine();
                ImGui::Text("%s", modes[line_idx].c_str());
                ImGui::PopID();
            }
            ImGui::EndCombo();
        }
        ImGuiWrapper::pop_combo_style();
        if (selection_idx != selection_out) {//do
            if (selection_out == 0) { m_selection.unlock_volume_selection_mode(); }
            m_selection.set_volume_selection_mode(selection_out == 1 ? Selection::Volume : Selection::Instance);
            if (selection_out == 1) { m_selection.lock_volume_selection_mode(); }
        }
        same_line_width += (label_width + item_width);
    }
    imgui->end();
 
    ImGuiWrapper::pop_toolbar_style();
 
    //BBS check ratio changed
    if (m_explosion_ratio != GLVolume::explosion_ratio) {
        for (GLVolume* volume : m_volumes.volumes) {
            volume->set_bounding_boxes_as_dirty();
        }
        GLVolume::explosion_ratio = m_explosion_ratio;
    }
}

Referenced by _render_assemble_control(), and _render_overlays().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_assemble_info()

void Slic3r::GUI::GLCanvas3D::_render_assemble_info ( ) const

private

{
    if (m_canvas_type != ECanvasType::CanvasAssembleView) {
        return;
    }
 
    if (m_selection.is_empty()) {
        return;
    }
 
    ImGuiWrapper* imgui = wxGetApp().imgui();
    auto canvas_w = float(get_canvas_size().get_width());
    auto canvas_h = float(get_canvas_size().get_height());
    float space_size = imgui->get_style_scaling() * 8.0f;
    float caption_max = imgui->calc_text_size(_L("Total Volume:")).x + 3 * space_size;
 
    ImGuiIO& io = ImGui::GetIO();
    ImFont* font = io.Fonts->Fonts[0];
    float origScale = font->Scale;
    font->Scale = 1.2;
    ImGui::PushFont(font);
    ImGui::PopFont();
    float margin = 10.0f * get_scale();
    imgui->set_next_window_pos(canvas_w - margin, canvas_h - margin, ImGuiCond_Always, 1.0f, 1.0f);
    ImGuiWrapper::push_common_window_style(get_scale()); // ORCA use window style for popups with title
    imgui->begin(_L("Assembly Info"), ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse);
    font->Scale = origScale;
    ImGui::PushFont(font);
    ImGui::PopFont();
 
    double size0 = m_selection.get_bounding_box().size()(0);
    double size1 = m_selection.get_bounding_box().size()(1);
    double size2 = m_selection.get_bounding_box().size()(2);
    if (!m_selection.is_empty()) {
        ImGui::Text("%s", _L("Volume:").ToUTF8().data()); ImGui::SameLine(caption_max);
        ImGui::Text("%.2f", size0 * size1 * size2);
        ImGui::Text("%s", _L("Size:").ToUTF8().data()); ImGui::SameLine(caption_max);
        ImGui::Text("%.2f x %.2f x %.2f", size0, size1, size2);
    }
    imgui->end();
    ImGuiWrapper::pop_common_window_style();
}

References _L, _render_assemble_info(), Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::ImGuiWrapper::calc_text_size(), CanvasAssembleView, Slic3r::GUI::ImGuiWrapper::end(), get_canvas_size(), get_scale(), Slic3r::GUI::ImGuiWrapper::get_style_scaling(), m_canvas_type, m_selection, Slic3r::GUI::ImGuiWrapper::pop_common_window_style(), Slic3r::GUI::ImGuiWrapper::push_common_window_style(), and Slic3r::GUI::ImGuiWrapper::set_next_window_pos().

Referenced by _render_assemble_info(), and _render_overlays().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_assemble_view_toolbar()

void Slic3r::GUI::GLCanvas3D::_render_assemble_view_toolbar ( ) const

private

{
    if (!m_assemble_view_toolbar.is_enabled())
        return;
 
    const Size cnv_size = get_canvas_size();
    const float gizmo_width = m_gizmos.get_scaled_total_width();
    const float separator_width = m_separator_toolbar.get_width();
    const float top = 0.5f * (float)cnv_size.get_height();
    const float main_toolbar_left = -0.5f * cnv_size.get_width() + get_main_toolbar_offset();
    const float left = main_toolbar_left + (m_main_toolbar.get_width() + gizmo_width + separator_width);
 
    m_assemble_view_toolbar.set_position(top, left);
    m_assemble_view_toolbar.render(*this);
}

References _render_assemble_view_toolbar(), get_canvas_size(), Slic3r::GUI::Size::get_height(), get_main_toolbar_offset(), Slic3r::GUI::Size::get_width(), m_assemble_view_toolbar, m_gizmos, m_main_toolbar, and m_separator_toolbar.

Referenced by _render_assemble_view_toolbar(), and _render_overlay_toolbars().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_assembly_tooltip_button()

float Slic3r::GUI::GLCanvas3D::_render_assembly_tooltip_button ( ImGuiWrapper * imgui_wrapper ) const

private

{
    const float text_height = imgui_wrapper->calc_text_size(_L("Part selection")).y;
    ImVec2      windowPos   = ImGui::GetWindowPos();
    float       x           = windowPos.x;
    float       y           = windowPos.y - ImGui::GetFrameHeight() - (5 * text_height);
    y -= ImGui::GetContentRegionMax().y + ImGui::GetFrameHeight(); // correct default ToolTipButton behaviour
 
    GLGizmoUtils::render_tooltip_button(imgui_wrapper, *this, m_shortcuts_assembly_view, x, y);
    ImGui::SameLine();
    ImGui::Dummy(ImVec2(12.f, 0.f));
 
    float scale = get_scale();
#ifdef WIN32
    int dpi = get_dpi_for_window(wxGetApp().GetTopWindow());
    scale *= (float) dpi / (float) DPI_DEFAULT;
#endif                                                   // WIN32
    ImVec2 button_size = ImVec2(25 * scale, 25 * scale); // ORCA: Use exact resolution will prevent blur on icon
 
    float same_line_width = button_size.x * 1.8; // with an space size
    ImGui::SameLine(same_line_width);
    same_line_width = imgui_wrapper->calc_text_size("|"sv).x + same_line_width + imgui_wrapper->calc_text_size("  "sv).x;
    imgui_wrapper->text_colored(ImGuiWrapper::COL_ACTIVE, "|");
    ImGui::SameLine(same_line_width);
 
    return same_line_width; // return the width of the space taken by the tooltip button and the separator
}

References _L, _render_assembly_tooltip_button(), Slic3r::GUI::ImGuiWrapper::calc_text_size(), Slic3r::GUI::ImGuiWrapper::COL_ACTIVE, Slic3r::GUI::DPI_DEFAULT, Slic3r::GUI::get_dpi_for_window(), get_scale(), m_shortcuts_assembly_view, Slic3r::GUI::GLGizmoUtils::render_tooltip_button(), scale(), and Slic3r::GUI::ImGuiWrapper::text_colored().

Referenced by _render_assemble_control(), and _render_assembly_tooltip_button().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_background()

void Slic3r::GUI::GLCanvas3D::_render_background ( )

private

{
    bool use_error_color = false;
    if (wxGetApp().is_editor()) {
        use_error_color = m_dynamic_background_enabled &&
        (current_printer_technology() != ptSLA || !m_volumes.empty());
 
        if (!m_volumes.empty())
            use_error_color &= _is_any_volume_outside();
        else {
            //BBS: use current plater's bounding box
            //BoundingBoxf3 test_volume = (m_config != nullptr) ? print_volume(*m_config) : BoundingBoxf3();
            BoundingBoxf3 test_volume = (const_cast<GLCanvas3D*>(this))->_get_current_partplate_print_volume();
            const BoundingBoxf3& path_bounding_box = m_gcode_viewer.get_paths_bounding_box();
            if (empty(path_bounding_box))
                use_error_color = false;
            else
                //BBS: use previous result
                use_error_color = (test_volume.radius() > 0.0) ? m_toolpath_outside : false;
            //use_error_color &= (test_volume.radius() > 0.0) ? !test_volume.contains(path_bounding_box) : false;
        }
    }
 
    // Draws a bottom to top gradient over the complete screen.
    glsafe(::glDisable(GL_DEPTH_TEST));
 
    ColorRGBA background_color = m_is_dark ? DEFAULT_BG_LIGHT_COLOR_DARK : DEFAULT_BG_LIGHT_COLOR;
    ColorRGBA error_background_color = m_is_dark ? ERROR_BG_LIGHT_COLOR_DARK : ERROR_BG_LIGHT_COLOR;
    const ColorRGBA bottom_color = use_error_color ? error_background_color : background_color;
 
    if (!m_background.is_initialized()) {
        m_background.reset();
 
        GLModel::Geometry init_data;
        init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P2T2 };
        init_data.reserve_vertices(4);
        init_data.reserve_indices(6);
 
        // vertices
        init_data.add_vertex(Vec2f(-1.0f, -1.0f), Vec2f(0.0f, 0.0f));
        init_data.add_vertex(Vec2f(1.0f, -1.0f),  Vec2f(1.0f, 0.0f));
        init_data.add_vertex(Vec2f(1.0f, 1.0f),   Vec2f(1.0f, 1.0f));
        init_data.add_vertex(Vec2f(-1.0f, 1.0f),  Vec2f(0.0f, 1.0f));
 
        // indices
        init_data.add_triangle(0, 1, 2);
        init_data.add_triangle(2, 3, 0);
 
        m_background.init_from(std::move(init_data));
    }
 
    GLShaderProgram* shader = wxGetApp().get_shader("background");
    if (shader != nullptr) {
        shader->start_using();
        shader->set_uniform("top_color", bottom_color);
        shader->set_uniform("bottom_color", bottom_color);
        m_background.render();
        shader->stop_using();
    }
 
    glsafe(::glEnable(GL_DEPTH_TEST));
}

References GLCanvas3D(), _get_current_partplate_print_volume(), _is_any_volume_outside(), _render_background(), Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), current_printer_technology(), DEFAULT_BG_LIGHT_COLOR, DEFAULT_BG_LIGHT_COLOR_DARK, Slic3r::empty(), ERROR_BG_LIGHT_COLOR, ERROR_BG_LIGHT_COLOR_DARK, Slic3r::GUI::GLModel::Geometry::format, GL_DEPTH_TEST, glDisable, glEnable, glsafe, m_background, m_dynamic_background_enabled, m_gcode_viewer, m_is_dark, m_toolpath_outside, m_volumes, Slic3r::GUI::GLModel::Geometry::P2T2, Slic3r::ptSLA, Slic3r::BoundingBox3Base< PointType >::radius(), Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), and Slic3r::GUI::GLModel::Geometry::Triangles.

Referenced by _render_background(), and _render_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_bed()

void Slic3r::GUI::GLCanvas3D::_render_bed	(	const Transform3d &	view_matrix,
		const Transform3d &	projection_matrix,
		bool	bottom,
		bool	show_axes )

private

{
    float scale_factor = 1.0;
#if ENABLE_RETINA_GL
    scale_factor = m_retina_helper->get_scale_factor();
#endif // ENABLE_RETINA_GL
 
    /*
    bool show_texture = ! bottom ||
            (m_gizmos.get_current_type() != GLGizmosManager::FdmSupports
          && m_gizmos.get_current_type() != GLGizmosManager::SlaSupports
          && m_gizmos.get_current_type() != GLGizmosManager::Hollow
          && m_gizmos.get_current_type() != GLGizmosManager::Seam
          && m_gizmos.get_current_type() != GLGizmosManager::MmSegmentation
          && m_gizmos.get_current_type() != GLGizmosManager::FuzzySkin);
    */
    //bool show_texture = true;
    //BBS set axes mode
    if (m_design_canvas) {
        // Design tab: triad at the bed centre = modeling origin (set every frame because
        // set_shape/set_axes_mode otherwise reset it to the bed corner).
        const Vec2d bc = m_bed.build_volume().bed_center();
        m_bed.set_axes_origin(Vec3d(bc.x(), bc.y(), 0.0));
    } else {
        // With the other plates hidden, the axes go to the current plate as in Preview.
        m_bed.set_axes_mode(m_main_toolbar.is_enabled() && !_hides_inactive_plates());
    }
    m_bed.render(*this, view_matrix, projection_matrix, bottom, scale_factor, show_axes);
}

References _hides_inactive_plates(), _render_bed(), m_bed, m_design_canvas, and m_main_toolbar.

Referenced by _render_bed(), and _render_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_below_plate_volumes()

void Slic3r::GUI::GLCanvas3D::_render_below_plate_volumes ( )

private

{
    if (!_is_below_plate_view_active() || m_volumes.empty())
        return;
 
    GLShaderProgram* shader = wxGetApp().get_shader("gouraud");
    if (shader == nullptr)
        return;
 
    const Camera& camera = wxGetApp().plater()->get_camera();
    const Transform3d& view_matrix = camera.get_view_matrix();
    const Transform3d& proj_matrix = camera.get_projection_matrix();
    const int object_idx = m_selection.get_object_idx();
    const int instance_idx = m_selection.get_instance_idx();
 
    // Depth test stays on so whatever is already in the depth buffer hides the ghost; depth writes
    // are off and back faces are culled, so each pixel blends only the near surface once.
    const GLboolean cull_face = ::glIsEnabled(GL_CULL_FACE);
    glsafe(::glEnable(GL_DEPTH_TEST));
    glsafe(::glEnable(GL_CULL_FACE));
    glsafe(::glCullFace(GL_BACK));
    glsafe(::glDepthMask(GL_FALSE));
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
    shader->start_using();
    // Keep z <= SINKING_Z_THRESHOLD, the complement of the clip the painting gizmo applies.
    shader->set_uniform("z_range", std::array<float, 2>{ -FLT_MAX, float(SINKING_Z_THRESHOLD) });
    shader->set_uniform("clipping_plane", m_volumes.get_clipping_plane());
    shader->set_uniform("use_color_clip_plane", false);
    shader->set_uniform("is_outline", false);
    shader->set_uniform("slope.actived", false);
    shader->set_uniform("print_volume.type", -1);
    shader->set_uniform("extruder_printable_heights", std::array<float, 3>{ 0.0f, 0.0f, 0.0f });
    shader->set_uniform("shadow_intensity", 0.0f);
 
    // simple_render() needs these to reach the plain surface; with ban_color_volume it ignores both.
    ModelObjectPtrs&       model_objects   = wxGetApp().model().objects;
    std::vector<ColorRGBA> extruder_colors = wxGetApp().plater()->get_extruders_colors();
 
    for (GLVolume* volume : m_volumes.volumes) {
        // is_active cannot gate this pass: the color painter marks the whole instance inactive and
        // draws it in its own gizmo pass. The instance and print-part checks below are what pick
        // this ghost out of the scene.
        if (volume->object_idx() != object_idx || volume->instance_idx() != instance_idx ||
            volume->is_modifier || volume->is_wipe_tower || volume->volume_idx() < 0)
            continue;
 
        volume->set_render_color();
        ColorRGBA color = volume->render_color;
        color.a(0.5f);
        volume->model.set_color(color);
 
        const Transform3d model_matrix = volume->world_matrix();
        shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
        shader->set_uniform("projection_matrix", proj_matrix);
        shader->set_uniform("volume_world_matrix", model_matrix);
        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
        shader->set_uniform("view_normal_matrix", view_normal_matrix);
        // Painted facets would send render() through the MMU segmentation sub-models, which carry
        // their own opaque filament colours; the ghost draws the plain surface so the alpha holds.
        volume->simple_render(shader, model_objects, extruder_colors, false, true);
    }
    shader->stop_using();
 
    glsafe(::glDisable(GL_BLEND));
    glsafe(::glDepthMask(GL_TRUE));
    if (cull_face == GL_FALSE)
        glsafe(::glDisable(GL_CULL_FACE));
}

References _is_below_plate_view_active(), _render_below_plate_volumes(), Slic3r::ColorRGBA::a(), camera, GL_BACK, GL_BLEND, GL_CULL_FACE, GL_DEPTH_TEST, GL_FALSE, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_TRUE, glBlendFunc, glCullFace, glDepthMask, glDisable, glEnable, glIsEnabled, glsafe, Slic3r::GLVolume::instance_idx(), m_selection, m_volumes, Slic3r::GLVolume::model, Slic3r::GLVolume::object_idx(), Slic3r::GLVolume::render_color, Slic3r::GUI::GLModel::set_color(), Slic3r::GLVolume::set_render_color(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLVolume::simple_render(), Slic3r::SINKING_Z_THRESHOLD, Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), Slic3r::GLVolume::volume_idx(), and Slic3r::GLVolume::world_matrix().

Referenced by _render_below_plate_volumes(), and _render_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_cad_grid()

void Slic3r::GUI::GLCanvas3D::_render_cad_grid	(	const Transform3d &	view_matrix,
		const Transform3d &	projection_matrix )

private

{
    const BuildVolume& build_volume = m_bed.build_volume();
    if (!build_volume.valid())
        return;
 
    const Vec2d        center = build_volume.bed_center();
    const BoundingBoxf bb     = build_volume.bounding_volume2d();
    if (!m_cad_grid_valid || m_cad_grid_center != center || m_cad_grid_bb != bb) {
        m_cad_grid_center = center;
        m_cad_grid_bb     = bb;
        m_cad_grid_valid  = true;
 
        // Same z as PartPlate::GROUND_Z_GRIDLINE (-0.26f): just below the bed fill (GROUND_Z =
        // -0.03f, which is drawn with the depth mask disabled) and above the physical bed model
        // (offset z = -0.41), so the grid never z-fights the bed quad. Chosen by construction,
        // not by magic number: it is the exact z the plate grid already uses on the shared bed.
        const float z = -0.26f;
 
        auto build_grid = [&z, &center, &bb](double step, GLModel& model) {
            std::vector<std::pair<Vec2d, Vec2d>> segs;
            // Constant-x (vertical on screen) lines, both directions from the centre so the
            // centre column itself is always present. Clipped to the bed bounding box so nothing
            // spills past the bed quad.
            for (double x = center.x(); x >= bb.min.x(); x -= step)
                segs.emplace_back(Vec2d(x, bb.min.y()), Vec2d(x, bb.max.y()));
            for (double x = center.x() + step; x <= bb.max.x(); x += step)
                segs.emplace_back(Vec2d(x, bb.min.y()), Vec2d(x, bb.max.y()));
            // Constant-y (horizontal on screen) lines, same centre-first convention.
            for (double y = center.y(); y >= bb.min.y(); y -= step)
                segs.emplace_back(Vec2d(bb.min.x(), y), Vec2d(bb.max.x(), y));
            for (double y = center.y() + step; y <= bb.max.y(); y += step)
                segs.emplace_back(Vec2d(bb.min.x(), y), Vec2d(bb.max.x(), y));
 
            GLModel::Geometry data;
            data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
            data.reserve_vertices(2 * segs.size());
            data.reserve_indices(2 * segs.size());
            for (const auto& s : segs) {
                data.add_vertex(Vec3f(float(s.first.x()), float(s.first.y()), z));
                data.add_vertex(Vec3f(float(s.second.x()), float(s.second.y()), z));
                const unsigned int vc = static_cast<unsigned int>(data.vertices_count());
                data.add_line(vc - 2, vc - 1);
            }
            model.init_from(std::move(data));
        };
 
        m_cad_grid_minor.reset();
        m_cad_grid_major.reset();
        build_grid(10.0, m_cad_grid_minor);
        build_grid(50.0, m_cad_grid_major);
    }
 
    if (!m_cad_grid_minor.is_initialized() || !m_cad_grid_major.is_initialized())
        return;
 
    GLShaderProgram* shader = wxGetApp().get_shader("flat");
    if (shader == nullptr)
        return;
 
    shader->start_using();
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
    shader->set_uniform("view_model_matrix", view_matrix);
    shader->set_uniform("projection_matrix", projection_matrix);
 
    // White every 5 cm, grey every 1 cm — the SAME in both themes, deliberately. There is no
    // "white bed" to vanish against: the plate is dark grey either way, DEFAULT_MODEL_COLOR
    // {0.326,0.337,0.337} on light and DEFAULT_MODEL_COLOR_DARK {0.255,0.255,0.283} on dark
    // (3DBed.cpp:185-186), a difference of 0.07. A per-theme palette here would be a branch
    // that buys nothing and one more thing to keep in step.
    //
    // For contrast with what this replaces: the plate's own grid uses LINE_TOP_DARK_COLOR, a
    // 0.43 grey, for BOTH its thin and its bold family — which is most of why the stock grid
    // reads as a flat mesh with no scale to it.
    const ColorRGBA minor_color(0.40f, 0.40f, 0.42f, 1.0f);
    const ColorRGBA major_color(0.90f, 0.90f, 0.90f, 1.0f);
 
    glsafe(::glLineWidth(1.0f));
    m_cad_grid_minor.set_color(minor_color);
    m_cad_grid_minor.render();
 
    glsafe(::glLineWidth(2.0f));
    m_cad_grid_major.set_color(major_color);
    m_cad_grid_major.render();
 
    glsafe(::glDisable(GL_BLEND));
}

Referenced by _render_cad_grid(), and _render_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_canvas_toolbar()

void Slic3r::GUI::GLCanvas3D::_render_canvas_toolbar ( )

private

{
    ImGuiWrapper &imgui    = *wxGetApp().imgui();
    float         sc       = get_scale();
 
    #ifdef WIN32
        const int dpi = get_dpi_for_window(wxGetApp().GetTopWindow());
        sc *= (float) dpi / (float) DPI_DEFAULT;
    #endif // WIN32
 
    ImVec2        btn_size = ImVec2(CANVAS_TOOLBAR_BUTTON, CANVAS_TOOLBAR_BUTTON) * sc;
    ImVec2        margin   = ImVec2(m_canvas_toolbar_pos[0] > 0 ? 0.f : (CANVAS_TOOLBAR_MARGIN * sc), CANVAS_TOOLBAR_MARGIN * sc);
    ImVec2        spacing  = ImVec2(CANVAS_TOOLBAR_SPACING, CANVAS_TOOLBAR_SPACING) * sc;
    ImVec2        padding  = ImVec2(CANVAS_TOOLBAR_PADDING, CANVAS_TOOLBAR_PADDING) * sc;
    Vec2i32       pos      = {
        m_canvas_toolbar_pos[0]        + margin.x,
        get_canvas_size().get_height() - margin.y
    };
    bool          zoom_btn = wxGetApp().show_canvas_zoom_button();
 
    imgui.set_next_window_pos(pos[0], pos[1], ImGuiCond_Always, 0, 1); // pivot bottom-left
 
    ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0    );
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding   , {0,0});
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing    , {0,0});
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding  , padding); // without padding images clipping
 
    imgui.begin(_L("Canvas Toolbar"), ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoBackground | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoMove |
                                           ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoScrollWithMouse);//
 
    // Section view, on top so its panel opens above the toolbar.
    const bool  section_view = is_section_view_active();
    ImTextureID s_normal_id  = m_gizmos.get_icon_texture_id(section_view ?
        (m_is_dark ? GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_SECTION_ACTIVE_DARK : GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_SECTION_ACTIVE) :
        (m_is_dark ? GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_SECTION_DARK        : GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_SECTION));
    ImTextureID s_hover_id   = m_gizmos.get_icon_texture_id(section_view ?
        (m_is_dark ? GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_SECTION_ACTIVE_DARK_HOVER : GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_SECTION_ACTIVE_HOVER) :
        (m_is_dark ? GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_SECTION_DARK_HOVER        : GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_SECTION_HOVER));
 
    if (ImGui::ImageButton3(s_normal_id, s_hover_id, btn_size))
        m_section_view->panel_open = !m_section_view->panel_open;
    else if (ImGui::IsItemHovered()) {
        if (const float wheel = ImGui::GetIO().MouseWheel; wheel != 0.f)
            set_section_view_ratio(get_section_view_ratio() + (wheel < 0.f ? -0.01 : 0.01));
        if (ImGui::IsMouseClicked(ImGuiMouseButton_Right))
            toggle_section_view();
        else if (ImGui::IsMouseClicked(ImGuiMouseButton_Middle))
            align_section_view_to_camera();
        imgui.tooltip(_L("Section view"), ImGui::GetFontSize() * 20.0f);
    }
    const ImVec2 section_panel_pos = ImGui::GetItemRectMin() - ImVec2(0.f, spacing.y);
 
    ImGui::Dummy({ 0, spacing.y});
 
    ImTextureID m_normal_id = m_gizmos.get_icon_texture_id(m_is_dark ? GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_MENU_DARK       : GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_MENU);
    ImTextureID m_hover_id  = m_gizmos.get_icon_texture_id(m_is_dark ? GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_MENU_DARK_HOVER : GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_MENU_HOVER);
 
    if (ImGui::ImageButton3(m_normal_id, m_hover_id, btn_size)) {
        if(!ImGui::IsPopupOpen("CanvasToolbarMenu")){
            ImGui::SetNextWindowPos(ImVec2(pos[0] + padding.x, pos[1] - padding.y - (zoom_btn ? (btn_size.y + spacing.y) : 0.f)), ImGuiCond_Always, ImVec2(0, 1)); // pivot bottom-left
            ImGui::OpenPopup("CanvasToolbarMenu");
        }
    }
 
    if(zoom_btn){
        ImGui::Dummy({ 0, spacing.y});
 
        ImTextureID z_normal_id = m_gizmos.get_icon_texture_id(m_is_dark ? GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_ZOOM_DARK       : GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_ZOOM);
        ImTextureID z_hover_id  = m_gizmos.get_icon_texture_id(m_is_dark ? GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_ZOOM_DARK_HOVER : GLGizmosManager::MENU_ICON_NAME::IC_CANVAS_ZOOM_HOVER);
 
        if (ImGui::ImageButton3(z_normal_id, z_hover_id, btn_size)) {
#ifdef SLIC3R_CAD
            // The Design tab selects and sketches outside the canvas's selection and volumes, so
            // it names what to frame. Framed along the current view, which is often square to a
            // sketch plane; an empty tab falls through to the bed.
            const BoundingBoxf3 design_box = m_design_sketch_tool != nullptr ? m_design_sketch_tool->fit_box(m_volumes) : BoundingBoxf3();
            if (design_box.defined)
                _zoom_to_box(design_box);
            else
#endif
            {
                select_view("plate");
                if (m_selection.is_empty()) {
                    if (m_canvas_type == ECanvasType::CanvasAssembleView)
                        zoom_to_volumes();
                    else
                        zoom_to_bed();
                } else {
                    zoom_to_selection();
                }
            }
        } else if (ImGui::IsItemHovered()) {
            auto tooltip_str_wx = _L("Fit camera to scene or selected object.");
            std::string tooltip_str = tooltip_str_wx.ToUTF8().data();
 
            float width = ImGui::CalcTextSize(tooltip_str.c_str()).x + imgui.scaled(2.0f);
            imgui.tooltip(tooltip_str, width);
        }
    }
 
    ImGui::PopStyleVar(4); // Window
 
    ImGui::PushStyleColor(ImGuiCol_PopupBg           , m_is_dark ? ImGuiWrapper::COL_TOOLBAR_BG_DARK : ImGuiWrapper::COL_TOOLBAR_BG);
    ImGui::PushStyleColor(ImGuiCol_Separator         , m_is_dark ? ImVec4(1, 1, 1, .20f) : ImVec4(0, 0, 0, .2f));
    ImGui::PushStyleColor(ImGuiCol_Text              , m_is_dark ? ImVec4(1, 1, 1, .88f) : ImVec4(50 / 255.f, 58 / 255.f, 61 / 255.f, 1.f));
    ImGui::PushStyleColor(ImGuiCol_TextDisabled      , m_is_dark ? ImVec4(1, 1, 1, .44f) : ImVec4(50 / 255.f, 58 / 255.f, 61 / 255.f, .5f));
    ImGui::PushStyleColor(ImGuiCol_HeaderHovered     , ImVec4(0, 0, 0, 0.f)); // bg color for menu item
    ImGui::PushStyleColor(ImGuiCol_BorderActive      , ImGuiWrapper::COL_ORCA);
    ImGui::PushStyleVar(ImGuiStyleVar_PopupBorderSize, 0.f     );
    ImGui::PushStyleVar(ImGuiStyleVar_PopupRounding  , 8.f * sc);
    ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.f * sc);
    ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding  , 2.f * sc);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding  , ImVec2(4.f, 10.f) * sc);
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing    , ImVec2(0.f, 8.f ) * sc);
 
    if (ImGui::BeginPopup("CanvasToolbarMenu", ImGuiWindowFlags_NoMove)) {
        ImGui::PushItemFlag(ImGuiItemFlags_SelectableDontClosePopup, true);
 
        Plater*    p   = wxGetApp().plater();
        AppConfig* cfg = wxGetApp().app_config;
 
        auto create_menu_item = [sc](
            const std::string& name,
            bool enable,
            bool condition,
            const std::function<void()>& action
        ) {
            ImGui::Dummy({2.f * sc,0});
            ImGui::SameLine();
            if (ImGui::BBLMenuItem(("        " + _u8L(name)).c_str(), nullptr, false, enable, ImGui::CalcTextSize(_u8L(name).c_str()).y))
                action();
            ImGui::SameLine(12.f * sc);
            ImGui::TextColored(enable ? ImVec4(1,1,1,1) : ImGui::GetStyleColorVec4(ImGuiCol_TextDisabled), "%s", into_u8(condition ? ImGui::VisibleIcon : ImGui::HiddenIcon).c_str());
        };
 
 
        create_menu_item( _utf8(L("3D Navigator")),
            m_canvas_type != ECanvasType::CanvasAssembleView, // not work on assembly
            wxGetApp().show_3d_navigator(),
            []{
                wxGetApp().toggle_show_3d_navigator();
                ImGui::CloseCurrentPopup(); // Close popup to show changes on UI
            }
        );
 
        create_menu_item( _utf8(L("Zoom button")),
            true, // work on all
            wxGetApp().show_canvas_zoom_button(),
            []{
                wxGetApp().toggle_canvas_zoom_button();
                ImGui::CloseCurrentPopup(); // Close popup to show changes on UI
            }
        );
 
        ImGui::Separator();
 
        create_menu_item( _utf8(L("Overhangs")),
            m_canvas_type == ECanvasType::CanvasView3D, // work only on prepare
            p->is_view3D_overhang_shown(),
            [p]{p->show_view3D_overhang(!p->is_view3D_overhang_shown());}
        );
 
        create_menu_item( _utf8(L("Outline")),
            m_canvas_type != ECanvasType::CanvasPreview, // not work on preview
            wxGetApp().show_outline(),
            []{wxGetApp().toggle_show_outline();}
        );
 
        create_menu_item( _utf8(L("Wireframe")),
            m_canvas_type != ECanvasType::CanvasPreview, // not work on preview
            p->is_show_wireframe(),
            [this, p]{p->toggle_show_wireframe(); m_dirty = true;}
        );
 
        // TRN View toggle that draws models see-through, so hidden parts show.
        create_menu_item( _utf8(L("X-Ray")),
            m_canvas_type != ECanvasType::CanvasPreview, // not work on preview
            p->is_show_xray(),
            [this, p]{p->toggle_show_xray(); m_dirty = true;}
        );
 
        create_menu_item( _utf8(L("Realistic View")),
            true, // work on all
            cfg->get_bool(SETTING_OPENGL_REALISTIC_MODE),
            [&cfg]{
                cfg->set_bool(SETTING_OPENGL_REALISTIC_MODE, !cfg->get_bool(SETTING_OPENGL_REALISTIC_MODE));
                cfg->save();
            }
        );
 
        ImGui::Separator();
 
        create_menu_item( _utf8(L("Perspective")),
            true, // work on all
            cfg->get_bool("use_perspective_camera"),
            [&cfg]{
                cfg->set_bool("use_perspective_camera", !(cfg->get_bool("use_perspective_camera")));
                wxGetApp().update_ui_from_settings();
            }
        );
 
        ImGui::Separator();
 
        create_menu_item( _utf8(L("Axes")),
            m_canvas_type != ECanvasType::CanvasAssembleView, // not work on assembly
            m_show_world_axes,
            [this]{toggle_world_axes_visibility(false);}
        );
 
        create_menu_item( _utf8(L("Gridlines")),
            m_canvas_type != ECanvasType::CanvasAssembleView, // not work on assembly
            wxGetApp().show_plate_gridlines(),
            []{wxGetApp().toggle_show_plate_gridlines();}
        );
 
        create_menu_item( _utf8(L("Focus mode")),
            m_canvas_type == ECanvasType::CanvasView3D && !m_design_canvas, // work only on prepare
            wxGetApp().focus_mode(),
            [this]{
                wxGetApp().toggle_focus_mode();
                if (wxGetApp().focus_mode())
                    zoom_to_plate(REQUIRES_ZOOM_TO_CUR_PLATE);
                m_dirty = true;
            }
        );
 
        ImGui::Separator();
 
        create_menu_item( _utf8(L("Labels")),
            m_canvas_type == ECanvasType::CanvasView3D, // work only on prepare
            p->are_view3D_labels_shown(),
            [p]{p->show_view3D_labels(!p->are_view3D_labels_shown());}
        );
 
        create_menu_item( _utf8(L("Center of mass")),
            m_canvas_type != ECanvasType::CanvasAssembleView && !m_design_canvas, // work on prepare and preview
            wxGetApp().show_center_of_mass(),
            [this]{wxGetApp().toggle_show_center_of_mass(); m_dirty = true;}
        );
 
        // Belt printers, G-code preview only: show the raw machine-frame G-code instead of
        // the designed (upright) view. This menu is the only place the toggle lives (plus
        // its shortcut); the reload is deferred (CallAfter) so the preview is not rebuilt
        // mid-render.
        if (m_canvas_type == ECanvasType::CanvasPreview && m_gcode_viewer.is_belt_view()) {
            ImGui::Separator();
            create_menu_item( _utf8(L("Show raw G-code (belt only)")),
                true,
                !m_gcode_viewer.is_belt_show_designed(), // eye lit = raw machine-frame G-code (designed view off)
                [this, p]{
                    m_gcode_viewer.toggle_belt_show_designed();
                    p->CallAfter([p]{ p->refresh_belt_view(); });
                }
            );
        }
 
        ImGui::PopItemFlag();
        ImGui::EndPopup();
    }
 
    ImGui::PopStyleColor(6);
    ImGui::PopStyleVar(6);
 
    imgui.end();
 
    _render_section_view_panel(section_panel_pos);
}

Referenced by _render_canvas_toolbar(), and _render_overlays().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_collapse_toolbar()

void Slic3r::GUI::GLCanvas3D::_render_collapse_toolbar ( ) const

private

{
    if (!m_collapse_toolbar_enabled)
        return;
 
    const CollapseSide side = collapse_side();
    if (side == CollapseSide::None) {
        return;
    }
 
    GLToolbar& collapse_toolbar = this->collapse_toolbar();
 
    const Size cnv_size = get_canvas_size();
    const float top  = 0.5f * (float)cnv_size.get_height();
    const float left = side == CollapseSide::Right ? 0.5f * (float) cnv_size.get_width() - (float) collapse_toolbar.get_width() :
                                                     -0.5f * (float) cnv_size.get_width();
 
    collapse_toolbar.set_position(top, left);
    collapse_toolbar.render(*this);
}

References _render_collapse_toolbar(), collapse_side(), collapse_toolbar(), get_canvas_size(), Slic3r::GUI::Size::get_height(), Slic3r::GUI::Size::get_width(), m_collapse_toolbar_enabled, Slic3r::GUI::None, and Slic3r::GUI::Right.

Referenced by _render_collapse_toolbar(), and _render_overlay_toolbars().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_current_gizmo()

void Slic3r::GUI::GLCanvas3D::_render_current_gizmo ( ) const

private

{
    //BBS update inv_zoom
    GLGizmoBase::INV_ZOOM = (float)wxGetApp().plater()->get_camera().get_inv_zoom();
    m_gizmos.render_current_gizmo();
}

References _render_current_gizmo(), Slic3r::GUI::GLGizmoBase::INV_ZOOM, and m_gizmos.

Referenced by _render_current_gizmo(), and _render_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_fps_overlay()

void Slic3r::GUI::GLCanvas3D::_render_fps_overlay ( int fps ) const

private

{
    const bool show_fps = _is_fps_overlay_enabled() && fps >= 0;
    const std::vector<FrameProfiler::Section>& sections = m_frame_profiler.sections();
    const bool show_timings = _is_render_timings_enabled() && !sections.empty();
    if (!show_fps && !show_timings)
        return;
 
    ImGuiWrapper& imgui = *wxGetApp().imgui();
    const float margin = 10.0f * get_scale();
    const ImVec2 display_size = ImGui::GetIO().DisplaySize;
    ImVec2 pos(display_size.x - margin, margin);
    // Last frame's size; zero until the overlay has been shown once.
    const ImGuiWindow* self = ImGui::FindWindowByName("###fps_overlay");
    const float left = pos.x - (self != nullptr ? self->Size.x : 0.0f);
    // The Preview legend takes the top-right corner.
    if (const ImGuiWindow* legend = ImGui::FindWindowByName("Legend"); m_canvas_type == ECanvasType::CanvasPreview && legend != nullptr && legend->Active)
        pos = ImVec2(legend->Pos.x - margin, legend->Pos.y);
    // The toolbar row can reach the corner on a narrow canvas; stack the overlay below it then.
    else if (m_main_toolbar.is_enabled() &&
             get_main_toolbar_offset() + m_main_toolbar.get_width() + m_separator_toolbar.get_width() + m_gizmos.get_scaled_total_width() + m_assemble_view_toolbar.get_width() > left)
        pos.y = std::max(m_main_toolbar.get_height(), m_gizmos.get_scaled_total_height()) + margin;
    ImGui::SetNextWindowPos(pos, ImGuiCond_Always, ImVec2(1.0f, 0.0f));
    ImGui::SetNextWindowBgAlpha(0.35f);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f * get_scale());
    imgui.begin(
        std::string("###fps_overlay"),
        ImGuiWindowFlags_AlwaysAutoResize |
        ImGuiWindowFlags_NoResize |
        ImGuiWindowFlags_NoCollapse |
        ImGuiWindowFlags_NoTitleBar |
        ImGuiWindowFlags_NoMove |
        ImGuiWindowFlags_NoSavedSettings |
        ImGuiWindowFlags_NoInputs);
    if (show_fps) {
        imgui.text(std::string("FPS: ") + std::to_string(fps));
        ImGui::SameLine();
        // The subset of those frames that redrew the scene rather than reusing the cached one.
        imgui.text(std::string("3D: ") + std::to_string(m_render_stats.get_scene_fps()));
    }
    if (show_timings && ImGui::BeginTable("frame_sections", 3, ImGuiTableFlags_SizingFixedFit)) {
        ImGui::TableSetupColumn("ms");
        ImGui::TableSetupColumn("CPU");
        ImGui::TableSetupColumn("GPU");
        ImGui::TableHeadersRow();
        double cpu_ms = 0.0;
        double gpu_ms = 0.0;
        auto row = [](const char* name, double cpu, double gpu) {
            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGui::TextUnformatted(name);
            ImGui::TableSetColumnIndex(1);
            ImGui::Text("%.2f", cpu);
            ImGui::TableSetColumnIndex(2);
            ImGui::Text("%.2f", gpu);
        };
        for (const FrameProfiler::Section& section : sections) {
            row(section.name, section.cpu_ms, section.gpu_ms);
            cpu_ms += section.cpu_ms;
            gpu_ms += section.gpu_ms;
        }
        row("total", cpu_ms, gpu_ms);
        ImGui::EndTable();
    }
    imgui.end();
    ImGui::PopStyleVar();
}

References _is_fps_overlay_enabled(), _is_render_timings_enabled(), _render_fps_overlay(), Slic3r::GUI::ImGuiWrapper::begin(), CanvasPreview, Slic3r::GUI::ImGuiWrapper::end(), get_main_toolbar_offset(), get_scale(), m_assemble_view_toolbar, m_canvas_type, m_frame_profiler, m_gizmos, m_main_toolbar, m_render_stats, m_separator_toolbar, and Slic3r::GUI::ImGuiWrapper::text().

Referenced by _render_fps_overlay(), and _render_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_frame()

void Slic3r::GUI::GLCanvas3D::_render_frame	(	bool	scene_dirty,
		bool	only_init = false )

private

{
    if (m_in_render) {
        // if called recursively, return
        m_dirty = true;
        return;
    }
 
    m_in_render = true;
    ++s_frames_in_progress;
    Slic3r::ScopeGuard in_render_guard([this]() { m_in_render = false; --s_frames_in_progress; });
    (void)in_render_guard;
 
    if (m_canvas == nullptr)
        return;
 
    //BBS: add enable_render
    if (!m_enable_render)
        return;
 
    // ensures this canvas is current and initialized
    if (!_is_shown_on_screen() || !_set_current() || !wxGetApp().init_opengl())
        return;
 
    if (!is_initialized() && !init())
        return;
 
    // If a scene reload was postponed while the canvas was hidden, consume it on first visible render.
    if (m_reload_delayed) {
        reload_scene(true);
        if (m_reload_delayed)
            return;
    }
 
    if (m_canvas_type == ECanvasType::CanvasView3D  && m_gizmos.get_current_type() == GLGizmosManager::Undefined) {
        enable_return_toolbar(false);
    }
    if (!m_main_toolbar.is_enabled())
        m_gcode_viewer.init(wxGetApp().get_mode(), wxGetApp().preset_bundle);
 
    if (! m_bed.build_volume().valid()) {
        // this happens at startup when no data is still saved under <>\AppData\Roaming\Slic3rPE
        post_event(SimpleEvent(EVT_GLCANVAS_UPDATE_BED_SHAPE));
        return;
    }
 
    if (only_init)
        return;
 
#if ENABLE_ENVIRONMENT_MAP
    if (wxGetApp().is_editor())
        wxGetApp().plater()->init_environment_texture();
#endif // ENABLE_ENVIRONMENT_MAP
 
    const Size& cnv_size = get_canvas_size();
    // Probably due to different order of events on Linux/GTK2, when one switched from 3D scene
    // to preview, this was called before canvas had its final size. It reported zero width
    // and the viewport was set incorrectly, leading to tripping glAsserts further down
    // the road (in apply_projection). That's why the minimum size is forced to 10.
    Camera& camera = wxGetApp().plater()->get_camera();
    camera.set_viewport(0, 0, std::max(10u, (unsigned int)cnv_size.get_width()), std::max(10u, (unsigned int)cnv_size.get_height()));
    camera.apply_viewport();
 
    if (camera.requires_zoom_to_bed) {
        zoom_to_bed();
        _resize((unsigned int)cnv_size.get_width(), (unsigned int)cnv_size.get_height());
        camera.requires_zoom_to_bed = false;
    }
 
    if (camera.requires_zoom_to_plate > REQUIRES_ZOOM_TO_PLATE_IDLE) {
        zoom_to_plate(camera.requires_zoom_to_plate);
        _resize((unsigned int)cnv_size.get_width(), (unsigned int)cnv_size.get_height());
        camera.requires_zoom_to_plate = REQUIRES_ZOOM_TO_PLATE_IDLE;
    }
 
    if (camera.requires_zoom_to_volumes) {
        zoom_to_volumes();
        _resize((unsigned int)cnv_size.get_width(), (unsigned int)cnv_size.get_height());
        camera.requires_zoom_to_volumes = false;
    }
 
    camera.apply_projection(_max_bounding_box(true, true, true));
 
    wxGetApp().imgui()->new_frame();
 
    if (_update_inactive_plates_visibility())
        scene_dirty = true;
 
    if (m_picking_enabled && !m_benchmarking) {
        if (m_rectangle_selection.is_dragging())
            // picking pass using rectangle selection
            _rectangular_selection_picking_pass();
        //BBS: enable picking when no volumes for partplate logic
        //else if (!m_volumes.empty())
        else {
            // regular picking pass
            _picking_pass();
 
#if ENABLE_RAYCAST_PICKING_DEBUG
            ImGuiWrapper& imgui = *wxGetApp().imgui();
            imgui.begin(std::string("Hit result"), ImGuiWindowFlags_AlwaysAutoResize);
            imgui.text("Picking disabled");
            imgui.end();
#endif // ENABLE_RAYCAST_PICKING_DEBUG
        }
    }
 
    const bool overlay_tick = m_fps_overlay_tick;
    m_fps_overlay_tick = false;
 
    // An overlay-only frame reuses the last scene pass. The overlay is rebuilt either way, and drawn
    // below once it is known whether the frame differs from the one on screen.
    const bool reuse_scene = !scene_dirty && _can_reuse_cached_scene(camera);
    // Only frames that redraw the scene are profiled.
    if (!reuse_scene && (_is_render_timings_enabled() || m_frame_profiler.is_averaging()))
        m_frame_profiler.begin_frame();
    Slic3r::ScopeGuard profiler_guard([this]() { m_frame_profiler.end_frame(); });
    if (!reuse_scene) {
        _render_scene(camera, cnv_size);
        if (!overlay_tick)
            m_render_stats.increment_scene_fps_counter();
    }
 
    if (m_canvas_type == ECanvasType::CanvasPreview && m_render_preview) {
        // BBS: GUI refactor: add canvas size as parameters
        _render_gcode_overlay(cnv_size.get_width(), cnv_size.get_height());
        m_frame_profiler.mark("legend");
    }
 
    // draw overlays
    _render_overlays();
    m_frame_profiler.mark("ui");
 
    const int current_fps = m_render_stats.get_fps_and_reset_if_needed();
    if (_is_fps_overlay_enabled() || _is_render_timings_enabled())
        _render_fps_overlay(current_fps);
    if (_is_fps_overlay_enabled()) {
        // The timer requests an overlay-only frame a second from now. A frame it requested
        // re-arms it only while a count is above zero.
        if (!overlay_tick || current_fps > 0 || m_render_stats.get_scene_fps() > 0)
            m_fps_overlay_timer.StartOnce(1000);
    }
 
    if (wxGetApp().plater()->is_render_statistic_dialog_visible()) {
        ImGui::ShowMetricsWindow();
 
        ImGuiWrapper& imgui = *wxGetApp().imgui();
        imgui.begin(std::string("Render statistics"), ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
        imgui.text("FPS (SwapBuffers() calls per second):");
        ImGui::SameLine();
        imgui.text(std::to_string(current_fps));
        ImGui::Separator();
        imgui.text("Compressed textures:");
        ImGui::SameLine();
        imgui.text(OpenGLManager::are_compressed_textures_supported() ? "supported" : "not supported");
        imgui.text("Max texture size:");
        ImGui::SameLine();
        imgui.text(std::to_string(OpenGLManager::get_gl_info().get_max_tex_size()));
        imgui.end();
    }
 
#if ENABLE_PROJECT_DIRTY_STATE_DEBUG_WINDOW
    if (wxGetApp().is_editor() && wxGetApp().plater()->is_view3D_shown())
        wxGetApp().plater()->render_project_state_debug_window();
#endif // ENABLE_PROJECT_DIRTY_STATE_DEBUG_WINDOW
 
#if ENABLE_CAMERA_STATISTICS
    camera.debug_render();
#endif // ENABLE_CAMERA_STATISTICS
 
#if ENABLE_IMGUI_STYLE_EDITOR
    if (wxGetApp().get_mode() == ConfigOptionMode::comDevelop)
        _render_style_editor();
#endif
 
 
    std::string tooltip;
 
  // Negative coordinate means out of the window, likely because the window was deactivated.
  // In that case the tooltip should be hidden.
    if ((m_mouse.position.x() >= 0. && m_mouse.position.y() >= 0.) || has_mouse_capture()) { // ORCA continue to capture mouse pos mid drag
        if (tooltip.empty())
            tooltip = m_layers_editing.get_tooltip(*this);
 
      if (tooltip.empty())
          tooltip = m_gizmos.get_tooltip();
 
      if (tooltip.empty())
          tooltip = m_main_toolbar.get_tooltip();
 
        //BBS: GUI refactor: GLToolbar
        if (tooltip.empty())
            tooltip = m_assemble_view_toolbar.get_tooltip();
 
      if (tooltip.empty())
            tooltip = collapse_toolbar().get_tooltip();
 
        // BBS
#if 0
      if (tooltip.empty())
            tooltip = wxGetApp().plater()->get_view_toolbar().get_tooltip();
#endif
    }
 
    // Suppress the regular object-name/toolbar tooltip while hovering an IMEX
    // ghost; the swatch overlay below stands in for it.
    if (m_hover_ghost_head >= 0)
        tooltip.clear();
 
    set_tooltip(tooltip);
 
    if (m_tooltip_enabled)
        m_tooltip.render(m_mouse.position, *this);
 
    // IMEX ghost hover overlay: layered on top of the normal tooltip pass.
    _render_imex_ghost_tooltip();
 
    wxGetApp().plater()->get_mouse3d_controller().render_settings_dialog(*this);
 
    if (m_canvas_type != ECanvasType::CanvasAssembleView) {
        float right_margin = SLIDER_DEFAULT_RIGHT_MARGIN;
        float bottom_margin = SLIDER_DEFAULT_BOTTOM_MARGIN;
        if (m_canvas_type == ECanvasType::CanvasPreview && m_gcode_viewer.has_data()) { // ORCA only shift position of notifiations when sliders / gcode_viewer exist
            float scale_factor = get_scale();
#ifdef WIN32
            int dpi = get_dpi_for_window(wxGetApp().GetTopWindow());
            scale_factor *= (float) dpi / (float) DPI_DEFAULT;
#endif // WIN32
            right_margin = SLIDER_RIGHT_MARGIN * scale_factor * GCODE_VIEWER_SLIDER_SCALE;
            bottom_margin = SLIDER_BOTTOM_MARGIN * scale_factor * GCODE_VIEWER_SLIDER_SCALE;
        }
        wxGetApp().plater()->get_notification_manager()->render_notifications(*this, get_overlay_window_width(), bottom_margin, right_margin);
        wxGetApp().plater()->get_dailytips()->render();
    }
    m_frame_profiler.mark("notifications");
 
    ImDrawData* draw_data = wxGetApp().imgui()->end_frame();
 
    std::optional<size_t> signature;
    if (_is_frame_skipping_enabled())
        signature = _overlay_signature(draw_data);
    m_frame_profiler.mark("imgui end");
 
    if (reuse_scene) {
        // A reused scene under an unchanged overlay is the frame already on screen.
        if (signature.has_value() && signature == m_presented_signature)
            return;
        m_scene_cache.render(m_background);
    }
 
    _render_overlay_toolbars();
    m_frame_profiler.mark("toolbars");
 
    wxGetApp().imgui()->render(draw_data);
    m_frame_profiler.mark("imgui draw");
 
    // On Wayland, eglSwapBuffers blocks when the canvas is hidden or
    // occluded. Skip the swap to avoid stalling the render loop.
    // Code run from inside this frame - a modal dialog a gizmo opened from its ImGui panel, a
    // synchronous paint of another canvas - may have made a different surface current. Bind this one
    // again before presenting, so the swap is not issued against a window the context no longer
    // belongs to: on Mesa/X11 that is a fatal BadMatch, not the no-op it is on other platforms. Draws
    // already issued before this point cannot be redirected - only this swap is protected.
    if (m_canvas->IsShownOnScreen() && _set_current()) {
        m_canvas->SwapBuffers();
        m_frame_profiler.mark("swap");
        if (!overlay_tick)
            m_render_stats.increment_fps_counter();
        m_presented_signature = signature;
    }
    else {
        if (m_canvas->IsShownOnScreen()) {
            // Logged once: if the rebind fails it does so every frame, and a warning per frame would
            // bury everything else.
            static bool rebind_failure_logged = false;
            if (!rebind_failure_logged) {
                rebind_failure_logged = true;
                BOOST_LOG_TRIVIAL(warning) << "GLCanvas3D: could not rebind the GL context to this canvas before "
                                              "SwapBuffers(); the frame is not presented";
            }
        }
        m_presented_signature.reset();
    }
}

References _can_reuse_cached_scene(), _is_fps_overlay_enabled(), _is_frame_skipping_enabled(), _is_render_timings_enabled(), _is_shown_on_screen(), _max_bounding_box(), _overlay_signature(), _picking_pass(), _rectangular_selection_picking_pass(), _render_fps_overlay(), _render_gcode_overlay(), _render_imex_ghost_tooltip(), _render_overlay_toolbars(), _render_overlays(), _render_scene(), _render_style_editor(), _resize(), _set_current(), _update_inactive_plates_visibility(), Slic3r::GUI::OpenGLManager::are_compressed_textures_supported(), Slic3r::GUI::ImGuiWrapper::begin(), camera, CanvasAssembleView, CanvasPreview, CanvasView3D, collapse_toolbar(), Slic3r::comDevelop, Slic3r::GUI::DPI_DEFAULT, enable_return_toolbar(), Slic3r::GUI::ImGuiWrapper::end(), Slic3r::GUI::GCODE_VIEWER_SLIDER_SCALE, get_canvas_size(), Slic3r::GUI::get_dpi_for_window(), Slic3r::GUI::OpenGLManager::get_gl_info(), Slic3r::GUI::Size::get_height(), get_overlay_window_width(), get_scale(), Slic3r::GUI::GLToolbar::get_tooltip(), Slic3r::GUI::Size::get_width(), has_mouse_capture(), init(), is_initialized(), m_assemble_view_toolbar, m_background, m_bed, m_benchmarking, m_canvas, m_canvas_type, m_dirty, m_enable_render, m_fps_overlay_tick, m_fps_overlay_timer, m_frame_profiler, m_gcode_viewer, m_gizmos, m_hover_ghost_head, m_in_render, m_layers_editing, m_main_toolbar, m_mouse, m_picking_enabled, m_presented_signature, m_rectangle_selection, m_reload_delayed, m_render_preview, m_render_stats, m_scene_cache, m_tooltip, m_tooltip_enabled, Slic3r::GUI::plater(), post_event(), reload_scene(), REQUIRES_ZOOM_TO_PLATE_IDLE, s_frames_in_progress, set_tooltip(), Slic3r::GUI::SLIDER_BOTTOM_MARGIN, Slic3r::GUI::SLIDER_DEFAULT_BOTTOM_MARGIN, Slic3r::GUI::SLIDER_DEFAULT_RIGHT_MARGIN, Slic3r::GUI::SLIDER_RIGHT_MARGIN, Slic3r::GUI::ImGuiWrapper::text(), Slic3r::GUI::GLGizmosManager::Undefined, zoom_to_bed(), zoom_to_plate(), and zoom_to_volumes().

Referenced by _refresh_if_shown_on_screen(), on_mouse(), and render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_fxaa_pass()

void Slic3r::GUI::GLCanvas3D::_render_fxaa_pass	(	unsigned int	width,
		unsigned int	height )

private

{
    if (width == 0 || height == 0)
        return;
 
    GLShaderProgram* shader = wxGetApp().get_shader("fxaa");
    if (shader == nullptr)
        return;
 
    GLTexture::copy_from_framebuffer(m_fxaa_texture_id, m_fxaa_texture_size, width, height, GL_LINEAR);
 
    glsafe(::glDisable(GL_DEPTH_TEST));
    glsafe(::glDisable(GL_BLEND));
    glsafe(::glClear(GL_COLOR_BUFFER_BIT));
 
    shader->start_using();
    shader->set_uniform("view_model_matrix", Transform3d::Identity());
    shader->set_uniform("projection_matrix", Transform3d::Identity());
    shader->set_uniform("uniform_texture", 0);
    shader->set_uniform("inv_tex_size", Vec2f(1.0f / static_cast<float>(width), 1.0f / static_cast<float>(height)));
 
    glsafe(::glActiveTexture(GL_TEXTURE0));
    glsafe(::glBindTexture(GL_TEXTURE_2D, m_fxaa_texture_id));
    m_background.render();
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
    shader->stop_using();
 
    glsafe(::glEnable(GL_DEPTH_TEST));
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
}

References _render_fxaa_pass(), Slic3r::GUI::GLTexture::copy_from_framebuffer(), GL_BLEND, GL_COLOR_BUFFER_BIT, GL_DEPTH_TEST, GL_LINEAR, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_TEXTURE0, GL_TEXTURE_2D, glActiveTexture, glBindTexture, glBlendFunc, glClear, glDisable, glEnable, glsafe, m_background, m_fxaa_texture_id, m_fxaa_texture_size, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Referenced by _render_fxaa_pass(), and _render_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_gcode()

void Slic3r::GUI::GLCanvas3D::_render_gcode	(	int	canvas_width,
		int	canvas_height )

private

{
    // Realistic view: the toolpaths receive the same depth map they were rendered into by
    // _render_shadows, which is what gives them object-on-object and self shadows. Intensity 0
    // short-circuits the lookup in the shader, so this is inert whenever the map is missing.
    if (_bind_gcode_shadow_map(true))
        m_gcode_viewer.set_shadow_map(4, m_shadow_light_vp, 0.35f, 1.0f / static_cast<float>(m_shadow_map_size));
    else
        m_gcode_viewer.set_shadow_map(4, Transform3d::Identity(), 0.0f, 0.0f);
 
    // The lighting term leaves the print dimmer and duller than the legend colours. Saturation
    // pays back the duller half in both modes; brightness only where something takes light off
    // again - realistic view with at least one lossy pass on - else the lift would just clip.
    const AppConfig* cfg = wxGetApp().app_config;
    const bool lossy_passes = cfg != nullptr && _is_realistic_view_enabled() &&
                              (_shadow_mode() != EShadowMode::Off || cfg->get_bool(SETTING_OPENGL_PHONG_SSAO));
    m_gcode_viewer.set_tone(lossy_passes ? 1.1f : 1.0f, 1.15f);
    m_gcode_viewer.set_light_top_dir(_static_light_dir_eye().value_or(Vec3d(-0.4574957, 0.4574957, 0.7624929)));
    m_gcode_viewer.set_gloss(_is_realistic_view_enabled() && cfg != nullptr && cfg->get_bool(SETTING_OPENGL_REALISTIC_GLOSS));
 
    m_gcode_viewer.render_scene(canvas_width, canvas_height);
    _bind_gcode_shadow_map(false);
}

References _bind_gcode_shadow_map(), _is_realistic_view_enabled(), _render_gcode(), _shadow_mode(), _static_light_dir_eye(), Slic3r::AppConfig::get_bool(), m_gcode_viewer, m_shadow_light_vp, m_shadow_map_size, Off, SETTING_OPENGL_PHONG_SSAO, and SETTING_OPENGL_REALISTIC_GLOSS.

Referenced by _render_gcode(), and _render_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_gcode_overlay()

void Slic3r::GUI::GLCanvas3D::_render_gcode_overlay	(	int	canvas_width,
		int	canvas_height )

private

{
    m_gcode_viewer.render_overlay(canvas_width, canvas_height, SLIDER_RIGHT_MARGIN * GCODE_VIEWER_SLIDER_SCALE);
    IMSlider *layers_slider = m_gcode_viewer.get_layers_slider();
    IMSlider *moves_slider  = m_gcode_viewer.get_moves_slider();
 
    if (layers_slider->is_need_post_tick_event()) {
        auto evt = new wxCommandEvent(EVT_CUSTOMEVT_TICKSCHANGED, m_canvas->GetId());
        evt->SetInt((int)layers_slider->get_post_tick_event_type());
        wxPostEvent(m_canvas, *evt);
        layers_slider->reset_post_tick_event();
    }
 
    if (layers_slider->is_dirty()) {
        set_volumes_z_range({layers_slider->GetLowerValueD(), layers_slider->GetHigherValueD()});
        if (m_gcode_viewer.has_data()) {
            m_gcode_viewer.set_layers_z_range({static_cast<unsigned int>(layers_slider->GetLowerValue()), static_cast<unsigned int>(layers_slider->GetHigherValue())});
        }
        layers_slider->set_as_dirty(false);
        post_event(SimpleEvent(EVT_GLCANVAS_UPDATE));
    }
 
    if (moves_slider->is_dirty()) {
        moves_slider->set_as_dirty(false);
        m_gcode_viewer.update_sequential_view_current((moves_slider->GetLowerValueD() - 1.0), static_cast<unsigned int>(moves_slider->GetHigherValueD() - 1.0));
        post_event(SimpleEvent(EVT_GLCANVAS_UPDATE));
    }
}

Referenced by _render_frame(), and _render_gcode_overlay().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_gcode_translucent()

void Slic3r::GUI::GLCanvas3D::_render_gcode_translucent	(	int	canvas_width,
		int	canvas_height )

private

{
    _bind_gcode_shadow_map(true);
    m_gcode_viewer.render_translucent_toolpaths(canvas_width, canvas_height);
    _bind_gcode_shadow_map(false);
}

References _bind_gcode_shadow_map(), _render_gcode_translucent(), and m_gcode_viewer.

Referenced by _render_gcode_translucent(), and _render_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_gizmos_overlay()

void Slic3r::GUI::GLCanvas3D::_render_gizmos_overlay ( )

private

{
/*#if ENABLE_RETINA_GL
//     m_gizmos.set_overlay_scale(m_retina_helper->get_scale_factor());
    const float scale = m_retina_helper->get_scale_factor()*wxGetApp().toolbar_icon_scale();
    m_gizmos.set_overlay_scale(scale); //! #ys_FIXME_experiment
#else
//     m_gizmos.set_overlay_scale(m_canvas->GetContentScaleFactor());
//     m_gizmos.set_overlay_scale(wxGetApp().em_unit()*0.1f);
    const float size = int(GLGizmosManager::Default_Icons_Size * wxGetApp().toolbar_icon_scale());
    m_gizmos.set_overlay_icon_size(size); //! #ys_FIXME_experiment
#endif */ /* __WXMSW__ */
    m_gizmos.render_overlay();
 
    if (m_gizmo_highlighter.m_render_arrow)
    {
        m_gizmos.render_arrow(*this, m_gizmo_highlighter.m_gizmo_type);
    }
}

References _render_gizmos_overlay(), m_gizmo_highlighter, and m_gizmos.

Referenced by _render_gizmos_overlay(), and _render_overlay_toolbars().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_imex_ghost_tooltip()

void Slic3r::GUI::GLCanvas3D::_render_imex_ghost_tooltip ( )

private

{
    if (m_hover_ghost_head < 0)
        return;
 
    // Hover state can outlive the ghosts that produced it: _picking_pass_imex_ghosts
    // only resets m_hover_ghost_head when it runs, and _picking_pass early-returns
    // (mouse drag, mouse off-canvas, gizmo drag) skip that reset. If the user switches
    // from an IMEX printer to a non-IMEX one during such a window, the plate clears its
    // ghost volumes but the stale head index survives — producing an orphan tooltip.
    // Validate against live ghosts and self-heal before rendering.
    const PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_plate(m_hover_ghost_plate);
    if (!plate || plate->get_imex_ghost_volumes().empty()) {
        m_hover_ghost_head  = -1;
        m_hover_ghost_plate = -1;
        return;
    }
 
    const auto t = wxGetApp().plater()->format_imex_ghost_tooltip(m_hover_ghost_head);
 
    ImGuiWrapper& imgui = *wxGetApp().imgui();
    const Vec2i32 mouse = m_mouse.position.cast<int>();
    const float cursor_offset = imgui.scaled(1.6f); // ~16px @ 100%, scales with DPI
    imgui.set_next_window_pos(float(mouse.x()) + cursor_offset, float(mouse.y()) + cursor_offset,
                              ImGuiCond_Always, 0.0f, 0.0f);
    imgui.begin(std::string("##imex_ghost_tooltip"),
                ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
                ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove |
                ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoSavedSettings |
                ImGuiWindowFlags_NoMouseInputs);
    // Color swatch + label on the same row. imgui.scaled() keeps it readable on high-DPI.
    const ImVec4 col(t.swatch.r(), t.swatch.g(), t.swatch.b(), t.swatch.a());
    const float swatch_size = imgui.scaled(1.4f);
    ImGui::ColorButton("##swatch", col,
        ImGuiColorEditFlags_NoBorder | ImGuiColorEditFlags_NoTooltip,
        ImVec2(swatch_size, swatch_size));
    ImGui::SameLine();
    imgui.text(t.label);
    imgui.end();
}

References Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::ImGuiWrapper::end(), Slic3r::GUI::PartPlate::get_imex_ghost_volumes(), m_hover_ghost_head, m_hover_ghost_plate, m_mouse, Slic3r::GUI::ImGuiWrapper::scaled(), Slic3r::GUI::ImGuiWrapper::set_next_window_pos(), and Slic3r::GUI::ImGuiWrapper::text().

Referenced by _render_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_imex_ghosts()

void Slic3r::GUI::GLCanvas3D::_render_imex_ghosts ( bool xray_pass = false )

private

{
    // Draws through whichever shader the caller bound: the shaded pass leaves gouraud current,
    // the X-Ray pass its own program. Both are fed per volume below; the uniforms a pass sets
    // once for itself are the caller's (see _render_imex_ghosts_xray for the X-Ray pass's).
    // GLVolume::render() only binds its mesh, so we must set the per-volume
    // matrices AND uniform_color that GLVolumeCollection::render would normally
    // set; otherwise ghosts pick up whatever the last main volume left behind.
    GLShaderProgram* shader = wxGetApp().get_current_shader();
    if (shader == nullptr)
        return;
 
    // Primary-volume live transform lookup: during a gizmo drag the GLVolume's
    // instance_transformation is the source of truth (the ModelInstance matrix
    // only catches up on mouse-up). Returning it from here makes ghosts track
    // the drag every frame instead of snapping when the user releases.
    auto primary_live_xf = [this](int obj_idx, int inst_idx) -> std::optional<Transform3d> {
        for (const GLVolume* v : m_volumes.volumes) {
            if (!v) continue;
            if (v->composite_id.object_id == obj_idx &&
                v->composite_id.instance_id == inst_idx)
                return v->get_instance_transformation().get_matrix();
        }
        return std::nullopt;
    };
 
    const Camera& camera = wxGetApp().plater()->get_camera();
    const Transform3d& view_matrix = camera.get_view_matrix();
    shader->set_uniform("projection_matrix", camera.get_projection_matrix());
    // Ghosts live outside the build volume check; disable the partly-inside path.
    shader->set_uniform("print_volume.type", -1);
    shader->set_uniform("slope.actived", false);
 
    // Only render ghosts for the active plate. Iterating every plate here causes
    // ghosts from background plates to bleed through into the active scene
    // (e.g. when entering paint mode), since the GL state is shared across the
    // whole canvas. Per-plate ghost volumes still live on each PartPlate so they
    // round-trip through 3MF saves; we just don't draw them when their plate
    // isn't the one the user is currently looking at.
    PartPlateList& ppl = wxGetApp().plater()->get_partplate_list();
    PartPlate* active_plate = ppl.get_curr_plate();
    if (active_plate) {
        // Refresh per-frame so ghost positions reflect the primary's live drag state,
        // and restamp ghost RGB from the live filament palette so color-only changes
        // (palette edits, late-loading project colors) never leave stale ghosts.
        active_plate->update_imex_ghost_transforms(primary_live_xf);
        active_plate->update_imex_ghost_colors();
        const auto& ghosts = active_plate->get_imex_ghost_volumes();
        for (const auto& g : ghosts) {
            if (!g || !g->is_active) continue;
            const Transform3d model_matrix = g->world_matrix();
            shader->set_uniform("volume_world_matrix", model_matrix);
            shader->set_uniform("slope.volume_world_normal_matrix",
                static_cast<Matrix3f>(model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose().cast<float>()));
            shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
            const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3)
                * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
            shader->set_uniform("view_normal_matrix", view_normal_matrix);
            g->set_render_color();
            // GLModel::render() pushes its own data.color into uniform_color,
            // so we must stamp the ghost's color onto the model before render
            // or it draws black. Pattern matches 3DScene.cpp:1099.
            // X-Ray derives its own coverage from view angle and multiplies the colour's alpha
            // into it, so a ghost carrying its translucency as well composites about three times
            // fainter than the body it mirrors. Hand that pass an opaque colour and let its
            // density be the only source of translucency.
            ColorRGBA ghost_color = g->render_color;
            if (xray_pass)
                ghost_color.a(1.0f);
            g->model.set_color(ghost_color);
            g->render();
        }
    }
}

References Slic3r::ColorRGBA::a(), camera, Slic3r::GLVolume::composite_id, Slic3r::GUI::PartPlateList::get_curr_plate(), Slic3r::GUI::PartPlate::get_imex_ghost_volumes(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::GLVolume::CompositeID::instance_id, m_volumes, Slic3r::GLVolume::CompositeID::object_id, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GUI::PartPlate::update_imex_ghost_colors(), and Slic3r::GUI::PartPlate::update_imex_ghost_transforms().

Referenced by _render_imex_ghosts_xray(), and _render_objects().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_imex_ghosts_xray()

void Slic3r::GUI::GLCanvas3D::_render_imex_ghosts_xray ( )

private

{
    GLShaderProgram* shader = wxGetApp().get_shader("xray");
    if (shader == nullptr)
        return;
 
    // The blend and depth state _render_xray_volumes() uses, plus its two-sided drawing: the
    // shader shades back faces too, so a hollow ghost shows its far wall like a real body does.
    glsafe(::glDepthMask(GL_FALSE));
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
    glsafe(::glDisable(GL_CULL_FACE));
 
    shader->start_using();
    // _render_imex_ghosts() sets the per-volume matrices and the color, but the two uniforms
    // the volume collection would have set for the whole pass are this pass's to supply, and
    // the vertex shader discards everything outside z_range - an unset one hides every ghost.
    shader->set_uniform("z_range", m_volumes.get_z_range());
    shader->set_uniform("clipping_plane", m_volumes.get_clipping_plane());
    _render_imex_ghosts(/*xray_pass=*/true);
    shader->stop_using();
 
    glsafe(::glEnable(GL_CULL_FACE));
    glsafe(::glDisable(GL_BLEND));
    glsafe(::glDepthMask(GL_TRUE));
}

References _render_imex_ghosts(), _render_imex_ghosts_xray(), GL_BLEND, GL_CULL_FACE, GL_FALSE, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_TRUE, glBlendFunc, glDepthMask, glDisable, glEnable, glsafe, m_volumes, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Referenced by _render_imex_ghosts_xray(), and _render_objects().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_imgui_select_plate_toolbar()

void Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar ( )

private

{
    if (!m_sel_plate_toolbar.is_enabled()) {
        if (!m_render_preview)
            m_render_preview = true;
        return;
    }
 
    _update_imgui_select_plate_toolbar();
 
    IMToolbarItem* all_plates_stats_item = m_sel_plate_toolbar.m_all_plates_stats_item;
 
    PartPlateList& plate_list = wxGetApp().plater()->get_partplate_list();
    size_t         sliced_plates_cnt = 0; // ORCA make it accesable for other conditions
 
    for (int i = 0; i < plate_list.get_plate_count(); i++) {
        if (i < m_sel_plate_toolbar.m_items.size()) {
            if (i == plate_list.get_curr_plate_index() && !all_plates_stats_item->selected)
                m_sel_plate_toolbar.m_items[i]->selected = true;
            else
                m_sel_plate_toolbar.m_items[i]->selected = false;
 
            m_sel_plate_toolbar.m_items[i]->percent = plate_list.get_plate(i)->get_slicing_percent();
 
            bool can_slice = plate_list.get_plate(i)->can_slice();
            bool is_empty  = plate_list.get_plate(i)->empty();
 
            if (plate_list.get_plate(i)->is_slice_result_valid()) {
                if ((!is_empty && can_slice) && plate_list.get_plate(i)->is_slice_result_ready_for_print())
                    m_sel_plate_toolbar.m_items[i]->slice_state = IMToolbarItem::SliceState::SLICED;
                else
                    m_sel_plate_toolbar.m_items[i]->slice_state = IMToolbarItem::SliceState::SLICE_FAILED;
            }
            else {
                // A plate using a mixed filament whose components are broken cannot be sliced,
                // so surface that on the plate toolbar the same way an unsliceable plate is.
                if ((!is_empty && !can_slice) || (plate_list.get_plate(i)->has_printable_instances() && !plate_list.get_plate(i)->can_slice())
                    || wxGetApp().plater()->sidebar().has_broken_mixed_filament(plate_list.get_plate(i)))
                    m_sel_plate_toolbar.m_items[i]->slice_state = IMToolbarItem::SliceState::SLICE_FAILED;
                else {
                    if (plate_list.get_plate(i)->get_slicing_percent() < 0.0f)
                        m_sel_plate_toolbar.m_items[i]->slice_state = IMToolbarItem::SliceState::UNSLICED;
                    else
                        m_sel_plate_toolbar.m_items[i]->slice_state = IMToolbarItem::SliceState::SLICING;
                }
            }
        }
    }
    if (m_sel_plate_toolbar.show_stats_item) {
        all_plates_stats_item->percent = 0.0f;
 
        for (auto plate : plate_list.get_nonempty_plate_list()) {
            if (plate->is_slice_result_valid() && plate->is_slice_result_ready_for_print())
                sliced_plates_cnt++;
        }
        all_plates_stats_item->percent = (float)(sliced_plates_cnt) / (float)(plate_list.get_nonempty_plate_list().size()) * 100.0f;
 
        if (all_plates_stats_item->percent == 0.0f)
            all_plates_stats_item->slice_state = IMToolbarItem::SliceState::UNSLICED;
        else if (sliced_plates_cnt == plate_list.get_nonempty_plate_list().size())
            all_plates_stats_item->slice_state = IMToolbarItem::SliceState::SLICED;
        else if (all_plates_stats_item->percent < 100.0f)
            all_plates_stats_item->slice_state = IMToolbarItem::SliceState::SLICING;
 
        for (auto toolbar_item : m_sel_plate_toolbar.m_items) {
            if(toolbar_item->slice_state == IMToolbarItem::SliceState::SLICE_FAILED) {
                all_plates_stats_item->slice_state = IMToolbarItem::SliceState::SLICE_FAILED;
                all_plates_stats_item->selected = false;
                break;
            }
        }
 
        // Changing parameters does not invalid all plates, need extra logic to validate
        bool gcode_result_valid = true;
        for (auto gcode_result : plate_list.get_nonempty_plates_slice_results()) {
            if (gcode_result->moves.size() == 0) {
                gcode_result_valid = false;
            }
        }
        if (all_plates_stats_item->selected && all_plates_stats_item->slice_state == IMToolbarItem::SliceState::SLICED && gcode_result_valid) {
            m_gcode_viewer.render_all_plates_stats(plate_list.get_nonempty_plates_slice_results());
            m_render_preview = false;
        }
        else{
            m_gcode_viewer.render_all_plates_stats(plate_list.get_nonempty_plates_slice_results(), false);
            m_render_preview = true;
        }
    }else
        m_render_preview = true;
 
    // places the toolbar on the top_left corner of the 3d scene
    float f_scale = get_scale();
    #ifdef WIN32
        const int dpi = get_dpi_for_window(wxGetApp().GetTopWindow());
        f_scale *= (float) dpi / (float) DPI_DEFAULT;
    #endif // WIN32
    Size cnv_size = get_canvas_size();
    auto canvas_w = float(cnv_size.get_width());
    auto canvas_h = float(cnv_size.get_height());
 
    m_sel_plate_toolbar.set_icon_size(100.0f * f_scale, 100.0f * f_scale);
 
    float button_width = m_sel_plate_toolbar.icon_width;
    float button_height = m_sel_plate_toolbar.icon_height;
 
    float frame_padding = 1.0f * f_scale;
    float margin_size = 4.0f * f_scale;
    float button_margin = frame_padding;
 
    const float y_offset = is_collapse_toolbar_on_left() ? (get_collapse_toolbar_height() + 5) : 0;
    // Make sure the window does not overlap the 3d navigator
    auto window_height_max = canvas_h - y_offset;
    if (wxGetApp().show_3d_navigator()) {
        window_height_max -= (128 * f_scale + 5);
    }
    else { // ORCA spacing for canvas menu
        window_height_max -= (96 * f_scale + 5);
    }
 
    // ORCA simplify and correct window size and margin calculations and get values from style
    ImGuiWrapper& imgui = *wxGetApp().imgui();
 
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(8.0f, 8.0f) * f_scale);
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing,   ImVec2(4.0f, 4.0f) * f_scale);
 
    int item_count           = m_sel_plate_toolbar.m_items.size() + (m_sel_plate_toolbar.show_stats_item ? 1 : 0);
    float window_height_calc = (item_count * (button_height + (margin_size + button_margin) * 2.0f) + (item_count - 1) * ImGui::GetStyle().ItemSpacing.y + ImGui::GetStyle().WindowPadding.y * 2.0f);
    bool  show_scroll        = m_sel_plate_toolbar.is_display_scrollbar && (window_height_calc > window_height_max);
    float scrollbar_size     = PLATE_TOOLBAR_SCROLLBAR * f_scale;
    float window_height      = std::min(window_height_calc, window_height_max);
    float window_width       = button_width + (margin_size + button_margin + ImGui::GetStyle().WindowPadding.x) * 2 + (show_scroll ? scrollbar_size : 0);
 
    ImVec4 window_bg     = m_is_dark ? ImVec4(.13f, .13f, .15f, .5f) : ImVec4(1.f, 1.f, 1.f, .7f);
    ImVec4 button_active = ImGuiWrapper::COL_ORCA; // ORCA: Use orca color for selected sliced plate border
    ImVec4 button_hover  = plate_toolbar_hover_color(m_is_dark);
    ImVec4 orca_active   = m_is_dark ? ImGuiWrapper::COL_ORCA_DARK       : ImGuiWrapper::COL_ORCA;
    ImVec4 orca_hover    = m_is_dark ? ImGuiWrapper::COL_ORCA_HOVER_DARK : ImGuiWrapper::COL_ORCA_HOVER;
    ImU32  plate_bg      = m_is_dark ? IM_COL32(255, 255, 255, 10) : IM_COL32(0, 0, 0, 10);
    ImU32  plate_dim     = m_is_dark ? IM_COL32(30, 30, 30, 100) : IM_COL32(0, 0, 0, 50);
    float  button_radius = 1.0f * f_scale;
    //ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.f, 0.f, 0.f, 1.0f));
    //use white text as the background switch to black
    ImGui::PushStyleColor(ImGuiCol_Text, m_is_dark ? ImVec4(.9f, .9f, .9f, 1) : ImVec4(.3f, .3f, .3f, 1)); // ORCA Plate number text > Add support for dark mode
    ImGui::PushStyleColor(ImGuiCol_WindowBg, window_bg);
    ImGui::PushStyleColor(ImGuiCol_ButtonActive, button_active);
    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, button_hover);
    push_plate_toolbar_scrollbar_style(m_is_dark, scrollbar_size);
 
    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, show_scroll ? (6.f * f_scale) : (button_radius + margin_size + frame_padding + ImGui::GetStyle().WindowPadding.x));
    ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, button_radius + margin_size);
 
    imgui.set_next_window_pos(canvas_w * 0 + 5.0f * f_scale, canvas_h * 0 + y_offset, ImGuiCond_Always, 0, 0); // ORCA Add slight gap on left edge so toolbar looks like floating and it creates separation with sidebar
    imgui.set_next_window_size(window_width, window_height, ImGuiCond_Always);
 
    if (show_scroll)
        imgui.begin(_L("Select Plate"), ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse);
    else
        imgui.begin(_L("Select Plate"), ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse);
    ImGui::SetWindowFontScale(1.2f);
 
    ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 2.0f * f_scale);
 
    ImVec2 size = ImVec2(button_width, button_height); // Size of the image we want to make visible
    ImVec4 bg_col = ImVec4(128.0f, 128.0f, 128.0f, 0.0f);
    ImVec4 tint_col = ImVec4(1.0f, 1.0f, 1.0f, 1.0f);               // No tint
    ImVec2 margin = ImVec2(margin_size, margin_size);
 
    if(m_sel_plate_toolbar.show_stats_item)
    {
        // draw image
        ImVec2 button_start_pos = ImGui::GetCursorScreenPos();
 
        auto stats_hover_rect = button_start_pos + ImGui::GetWindowPos() - ImGui::GetCurrentWindow()->Scroll;
        bool is_stats_hovered = ImGui::IsMouseHoveringRect(stats_hover_rect, stats_hover_rect + size);
 
        if (all_plates_stats_item->selected) {
            auto border_color = is_stats_hovered ? ImGuiWrapper::COL_ORCA_HOVER : ImGuiWrapper::COL_ORCA;
            ImGui::PushStyleColor(ImGuiCol_Button       , border_color);
            ImGui::PushStyleColor(ImGuiCol_ButtonHovered, border_color);
            ImGui::PushStyleColor(ImGuiCol_ButtonActive , border_color);
        }
        else {
            ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(128.0f, 128.0f, 128.0f, 0.0f));
            if (all_plates_stats_item->slice_state == IMToolbarItem::SliceState::SLICE_FAILED) {
                ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGui::GetStyleColorVec4(ImGuiCol_Button));
                ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImGui::GetStyleColorVec4(ImGuiCol_Button));
            }
            else {
                ImGui::PushStyleColor(ImGuiCol_ButtonHovered, button_hover);
                ImGui::PushStyleColor(ImGuiCol_ButtonActive, button_hover);
            }
        }
 
        ImVec4 text_clr = m_is_dark ? ImVec4(.9f, .9f, .9f, 1) : ImVec4(.3f, .3f, .3f, 1);;
        ImTextureID btn_texture_id;
        if (all_plates_stats_item->slice_state == IMToolbarItem::SliceState::UNSLICED || all_plates_stats_item->slice_state == IMToolbarItem::SliceState::SLICING){
            btn_texture_id = (ImTextureID)(intptr_t)(m_process->running() ? all_plates_stats_item->image_slicing.get_id() : all_plates_stats_item->image_idle.get_id());
        } else if (all_plates_stats_item->slice_state == IMToolbarItem::SliceState::SLICE_FAILED) {
            btn_texture_id = (ImTextureID)(intptr_t)(all_plates_stats_item->image_failed.get_id());
        } else {
            btn_texture_id = (ImTextureID)(intptr_t)(all_plates_stats_item->image_stats.get_id());
        }
 
        if (ImGui::ImageButton2(btn_texture_id, size, {0,0}, {1,1}, frame_padding, bg_col, tint_col, margin)) {
            if (all_plates_stats_item->slice_state != IMToolbarItem::SliceState::SLICE_FAILED) {
                if (m_process && !m_process->running()) {
                    for (int i = 0; i < m_sel_plate_toolbar.m_items.size(); i++) {
                        m_sel_plate_toolbar.m_items[i]->selected = false;
                    }
                    all_plates_stats_item->selected = true;
                    wxGetApp().plater()->update(true, true);
                    wxCommandEvent evt = wxCommandEvent(EVT_GLTOOLBAR_SLICE_ALL);
                    wxPostEvent(wxGetApp().plater(), evt);
                }
            }
        }
 
        ImGui::PopStyleColor(3);
 
        ImVec2 start_pos = ImVec2(button_start_pos.x + frame_padding + margin.x, button_start_pos.y + frame_padding + margin.y);
 
        // ORCA add more useful information about slicing process and use progress bar on stats button
        std::string text_top;
        std::string text_bottom;
        ImVec2 bar_size         = ImVec2(size.x - margin.x * 2, 5.0f * f_scale);
        ImVec2 bar_bg_bgn       = start_pos + ImVec2(margin.x, size.y - bar_size.y - margin.y);
        ImVec2 bar_bg_end       = bar_bg_bgn + bar_size;
        int    total_plates_cnt = plate_list.get_nonempty_plate_list().size();
        ImGui::GetWindowDrawList()->AddRectFilled(start_pos, start_pos + size, plate_bg, button_radius); // Button background
 
        if (all_plates_stats_item->slice_state == IMToolbarItem::SliceState::UNSLICED || all_plates_stats_item->slice_state == IMToolbarItem::SliceState::SLICING) {
            float bar_current_perc_pos  = 0;
            float bar_total_perc_pos    = all_plates_stats_item->percent * (bar_size.x / 100.0f);
            int   current_slicing_plate = 0;
            if (m_process->running()) {
                for (int i = 0; i < total_plates_cnt; i++) {
                    if (m_sel_plate_toolbar.m_items[i]->slice_state == IMToolbarItem::SliceState::SLICING) {
                        current_slicing_plate = i;
                        bar_current_perc_pos  = m_sel_plate_toolbar.m_items[i]->percent * (bar_size.x / total_plates_cnt / 100.0f);
                    }
                }
                text_top = _u8L("Slicing") + ": " + std::to_string(current_slicing_plate + 1);
            } else {
                text_top = _u8L("Slice all");
            }
            text_bottom = std::to_string(sliced_plates_cnt) + " / " + std::to_string(total_plates_cnt);
            ImVec2 bar_fg_end = ImVec2(bar_bg_bgn.x + bar_total_perc_pos + bar_current_perc_pos, bar_bg_end.y);
            ImGui::GetWindowDrawList()->AddRectFilled(bar_bg_bgn, bar_bg_end, IM_COL32(128, 128, 128, 255), bar_size.y); // BAR BACKGROUND
            ImGui::GetWindowDrawList()->AddRectFilled(bar_bg_bgn, bar_fg_end, IM_COL32(0, 150, 136, 255),   bar_size.y); // BAR PROGRESS
        }
        else if (all_plates_stats_item->slice_state == IMToolbarItem::SliceState::SLICE_FAILED) {
            text_top    = _u8L("Failed");
            text_bottom = std::to_string(sliced_plates_cnt) + " / " + std::to_string(total_plates_cnt);
            ImGui::GetWindowDrawList()->AddRectFilled(bar_bg_bgn, bar_bg_end, IM_COL32(225, 74, 74, 255),   bar_size.y);
        }
        else if (all_plates_stats_item->slice_state == IMToolbarItem::SliceState::SLICED) {
            text_top    = _u8L("All Plates");
            text_bottom = _u8L("Stats");
        }
 
        // draw text
        GImGui->FontSize = 15.0f * f_scale;
        ImGui::PushStyleColor(ImGuiCol_Text, text_clr);
        ImVec2 text_size = ImGui::CalcTextSize(text_top.c_str());
        ImVec2 text_start_pos = ImVec2(start_pos.x + (button_width - text_size.x) / 2, start_pos.y + 3.0f * button_height / 5.0f);
        ImGui::RenderText(text_start_pos, text_top.c_str());
        text_size = ImGui::CalcTextSize(text_bottom.c_str());
        text_start_pos = ImVec2(start_pos.x + (button_width - text_size.x) / 2, text_start_pos.y + ImGui::GetTextLineHeight());
        ImGui::RenderText(text_start_pos, text_bottom.c_str());
        ImGui::PopStyleColor();
        ImGui::SetWindowFontScale(1.2f);
    }
 
    for (int i = 0; i < m_sel_plate_toolbar.m_items.size(); i++) {
        IMToolbarItem* item = m_sel_plate_toolbar.m_items[i];
 
        auto current_plate = plate_list.get_plate(i);
        bool can_slice     = current_plate->can_slice();
        bool is_empty      = current_plate->empty();
 
        // draw image
        ImVec2 button_start_pos = ImGui::GetCursorScreenPos();
        ImGui::PushID(i);
        ImVec2 uv0 = ImVec2(0.0f, 1.0f);    // UV coordinates for lower-left
        ImVec2 uv1 = ImVec2(1.0f, 0.0f);    // UV coordinates in our texture
 
        auto button_pos = ImGui::GetCursorPos();
        ImGui::SetCursorPos(button_pos + margin);
 
        ImGui::Image(item->texture_id, size, uv0, uv1, tint_col);
 
        ImGui::SetCursorPos(button_pos);
 
        // invisible button
        auto button_size = size + margin + margin + ImVec2(2 * frame_padding, 2 * frame_padding);
        ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 2.0f * f_scale);
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(.0f, .0f, .0f, .0f));
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(.0f, .0f, .0f, .0f));
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(.0f, .0f, .0f, .0f));
        // Translate window pos to abs pos, also account for the window scrolling
        auto hover_rect = button_pos + ImGui::GetWindowPos() - ImGui::GetCurrentWindow()->Scroll;
        bool is_plate_hovered = ImGui::IsMouseHoveringRect(hover_rect, hover_rect + button_size);
 
        if (item->selected)
            ImGui::PushStyleColor(ImGuiCol_Border, is_plate_hovered ? ImGuiWrapper::COL_ORCA_HOVER : ImGuiWrapper::COL_ORCA);
        else
            ImGui::PushStyleColor(ImGuiCol_Border, is_plate_hovered ? button_hover : ImVec4(.0f, .0f, .0f, .0f));
 
        if(ImGui::Button("##invisible_button", button_size)){
            // ORCA switch back to prepare tab when clicked failed plates
            if (!is_empty && item->slice_state == IMToolbarItem::SliceState::SLICE_FAILED){
                if (m_canvas != nullptr && !wxGetApp().is_closing()) {
                    m_canvas->CallAfter([this, i]() {
                        auto& app = wxGetApp();
                        if (!app.is_closing()){
                            auto* plater = app.plater();
                            if (plater){
                                plater->select_view_3D("3D"); // ensure its in 3D view
                                plater->select_plate(i);
                                zoom_to_bed();
                                auto* view3d_canvas = plater->get_view3D_canvas3D();
                                if(view3d_canvas){
                                    view3d_canvas->get_gizmos_manager().reset_all_states(); // close all gizmos
                                    view3d_canvas->reload_scene(true);
                                }
                                app.mainframe->select_tab(TAB_ID_PREPARE);
                            }
                        }
                    });
                }
            }
            else if (m_process && !m_process->running()) {
                all_plates_stats_item->selected = false;
                bool was_active = item->selected;
                item->selected = true;
                // begin to slicing plate
                if (item->slice_state != IMToolbarItem::SliceState::SLICED)
                    wxGetApp().plater()->update(true, true);
                wxCommandEvent* evt = new wxCommandEvent(EVT_GLTOOLBAR_SELECT_SLICED_PLATE);
                // ORCA dont reset viewing angle if item was active and non sliced to allow making comparisons on parameter changes
                if(!was_active || (was_active && item->slice_state == IMToolbarItem::SliceState::SLICED)) 
                    evt->SetExtraLong(1); // 1 = skip zooming plate
                evt->SetInt(i);
                wxQueueEvent(wxGetApp().plater(), evt);
            }
        }
        ImGui::PopStyleColor(4);
        ImGui::PopStyleVar();
 
        ImVec2 start_pos = ImVec2(button_start_pos.x + frame_padding + margin.x, button_start_pos.y + frame_padding + margin.y);
        ImVec2 size      = ImVec2(button_width, button_height);
        ImVec2 end_pos   = ImVec2(start_pos.x + size.x, start_pos.y + size.y);
        // ORCA show additional information depends on state
        auto draw_info_btn = [end_pos, f_scale, margin](std::string str, ImVec4 bg_color, ImVec4 fg_color){
            GImGui->FontSize = 15.0f * f_scale;
            ImVec2 txt_slice_sz  = ImGui::CalcTextSize(str.c_str());
            ImVec2 btn_pad       = ImVec2(8.f, 1.f) * f_scale;
            ImVec2 txt_slice_pos = end_pos - txt_slice_sz - margin - btn_pad;
            ImVec2 txt_slice_end = end_pos - margin - btn_pad;
            ImGui::GetWindowDrawList()->AddRectFilled(txt_slice_pos - btn_pad, txt_slice_end + btn_pad, ImGui::GetColorU32(bg_color), (txt_slice_sz.y + btn_pad.y) * .5f);
            ImGui::PushStyleColor(ImGuiCol_Text, fg_color);
            ImGui::RenderText(txt_slice_pos, str.c_str());
            ImGui::PopStyleColor(1);
            ImGui::SetWindowFontScale(1.2f);
        };
 
        if (is_empty){
            ImGui::GetWindowDrawList()->AddRectFilled(start_pos, end_pos, plate_dim, button_radius);
        } else if (can_slice && item->slice_state == IMToolbarItem::SliceState::UNSLICED) {
            ImGui::GetWindowDrawList()->AddRectFilled(start_pos, end_pos, plate_dim, button_radius);
            // ORCA add slice button to guide user
            bool is_processing = m_process && m_process->running() ;
            draw_info_btn(_u8L("Slice"),
                is_processing ? window_bg : (is_plate_hovered ? orca_hover : orca_active),
                m_is_dark ? ImVec4(.9f, .9f, .9f, 1) : (is_processing ? ImVec4(.3f, .3f, .3f, 1) : ImVec4(1, 1, 1, 1))
            );
        } else if (item->slice_state == IMToolbarItem::SliceState::SLICING) {
            // ORCA use bottom to top for shade animation that matches with printing / slicing orientation
            ImVec2 rect_size = ImVec2(button_width, button_height * item->percent / 100.0f);
            ImVec2 rect_start_pos = ImVec2(start_pos.x, start_pos.y);
            ImVec2 rect_end_pos = ImVec2(start_pos.x + button_width, start_pos.y + button_height - rect_size.y);
            ImGui::GetWindowDrawList()->AddRectFilled(start_pos, end_pos, plate_bg, button_radius);
            ImGui::GetWindowDrawList()->AddRectFilled(rect_start_pos, rect_end_pos, plate_dim, button_radius);
            // ORCA show percentage as text
            draw_info_btn(std::to_string(int(item->percent)) + "%", 
                window_bg,
                m_is_dark ? ImVec4(.9f, .9f, .9f, 1) : ImVec4(.3f, .3f, .3f, 1)
            );
        } else if (!is_empty && (!can_slice || item->slice_state == IMToolbarItem::SliceState::SLICE_FAILED)) {
            // Draw exclamation mark that matches with icon
            ImVec2 center  = ImVec2(start_pos.x + button_width/2, start_pos.y + button_height/2 - ImGui::GetTextLineHeight() * .5f);
            auto draw_list =ImGui::GetWindowDrawList();
            auto clr = m_is_dark ? IM_COL32(60, 44, 48, 255) : IM_COL32(202, 186, 186, 255);
            draw_list->AddRectFilled(start_pos, end_pos, IM_COL32(64, 1, 1, 64), button_radius);
            draw_list->AddCircleFilled(center, 14.f * f_scale,IM_COL32(225, 74, 74, 255));
            draw_list->AddRectFilled(center - ImVec2(2.f, 10.f) * f_scale, center + ImVec2(2.f, 4.f) * f_scale, clr, 2.f * f_scale);
            draw_list->AddCircleFilled(center + ImVec2(0, 8.f * f_scale),2.f * f_scale, clr);
            draw_info_btn(_u8L("Review"),
                ImGui::ColorConvertU32ToFloat4(is_plate_hovered ? IM_COL32(239, 88, 88, 255) : IM_COL32(225, 74, 74, 255)),
                m_is_dark ? ImVec4(.9f, .9f, .9f, 1) : ImVec4(1, 1, 1, 1)
            );
        } else if (item->slice_state == IMToolbarItem::SliceState::SLICED) {
            ImGui::GetWindowDrawList()->AddRectFilled(start_pos, end_pos, plate_bg, button_radius);
        }
 
        // draw text
        GImGui->FontSize = 18.0f * f_scale; // ORCA fix font scaling
        ImVec2 text_start_pos = ImVec2(start_pos.x + 4.0f * f_scale, start_pos.y + 2.0f * f_scale); // ORCA move close to corner to prevent overlapping with preview
        ImGui::RenderText(text_start_pos, std::to_string(i + 1).c_str());
        ImGui::SetWindowFontScale(1.2f); // ORCA fix font scaling
 
        ImGui::PopID();
    }
    ImGui::SetWindowFontScale(1.0f);
    ImGui::PopStyleColor(8);
    ImGui::PopStyleVar(7);
 
    m_sel_plate_toolbar.is_display_scrollbar = plate_toolbar_keeps_scrollbar(show_scroll, scrollbar_size);
 
    imgui.end();
}

Referenced by _render_imgui_select_plate_toolbar(), and _render_overlays().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_main_toolbar()

void Slic3r::GUI::GLCanvas3D::_render_main_toolbar ( )

private

{
    if (!m_main_toolbar.is_enabled())
        return;
 
    const Size cnv_size = get_canvas_size();
    const float top = 0.5f * (float)cnv_size.get_height();
 
    const float left = -0.5f * cnv_size.get_width() + get_main_toolbar_offset();
    m_main_toolbar.set_position(top, left);
    m_main_toolbar.render(*this);
    if (m_toolbar_highlighter.m_render_arrow)
        m_main_toolbar.render_arrow(*this, m_toolbar_highlighter.m_toolbar_item);
}

References _render_main_toolbar(), get_canvas_size(), Slic3r::GUI::Size::get_height(), get_main_toolbar_offset(), Slic3r::GUI::Size::get_width(), m_main_toolbar, and m_toolbar_highlighter.

Referenced by _render_main_toolbar(), and _render_overlay_toolbars().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_objects()

void Slic3r::GUI::GLCanvas3D::_render_objects	(	GLVolumeCollection::ERenderType	type,
		bool	with_outline = true )

private

{
    if (m_volumes.empty())
        return;
 
    glsafe(::glEnable(GL_DEPTH_TEST));
 
    m_camera_clipping_plane = _get_volumes_clipping_plane();
 
    if (m_picking_enabled)
        // Update the layer editing selection to the first object selected, update the current object maximum Z.
        m_layers_editing.select_object(*m_model, this->is_layers_editing_enabled() ? m_selection.get_object_idx() : -1);
 
    if (const BuildVolume &build_volume = m_bed.build_volume(); build_volume.valid()) {
        switch (build_volume.type()) {
        case BuildVolume_Type::Rectangle: {
            const BoundingBox3Base<Vec3d> bed_bb = build_volume.bounding_volume().inflated(BuildVolume::SceneEpsilon);
            m_volumes.set_print_volume({ 0, // Rectangle
                { float(bed_bb.min.x()), float(bed_bb.min.y()), float(bed_bb.max.x()), float(bed_bb.max.y()) },
                { 0.0f, float(build_volume.printable_height()) } });
            break;
        }
        case BuildVolume_Type::Circle: {
            m_volumes.set_print_volume({ 1, // Circle
                { unscaled<float>(build_volume.circle().center.x()), unscaled<float>(build_volume.circle().center.y()), unscaled<float>(build_volume.circle().radius + BuildVolume::SceneEpsilon), 0.0f },
                { 0.0f, float(build_volume.printable_height() + BuildVolume::SceneEpsilon) } });
            break;
        }
        default:
        case BuildVolume_Type::Convex:
        case BuildVolume_Type::Custom: {
            m_volumes.set_print_volume({ static_cast<int>(type),
                { -FLT_MAX, -FLT_MAX, FLT_MAX, FLT_MAX },
                { -FLT_MAX, FLT_MAX } }
            );
        }
        }
        if (m_requires_check_outside_state) {
            m_volumes.check_outside_state(build_volume, nullptr, nullptr);
            m_requires_check_outside_state = false;
        }
    }
 
    if (m_use_clipping_planes)
        m_volumes.set_z_range(-m_clipping_planes[0].get_data()[3], m_clipping_planes[1].get_data()[3]);
    else
        m_volumes.set_z_range(-FLT_MAX, FLT_MAX);
 
    GLGizmosManager& gm = get_gizmos_manager();
    GLGizmoBase* current_gizmo = gm.get_current();
    if (current_gizmo && !current_gizmo->apply_clipping_plane()) {
        m_volumes.set_clipping_plane(ClippingPlane::ClipsNothing().get_data());
    }
    else {
        m_volumes.set_clipping_plane(m_camera_clipping_plane.get_data());
    }
    if (m_canvas_type == CanvasAssembleView || !m_sinking_contours_enabled)
        m_volumes.set_show_sinking_contours(false);
    else
        m_volumes.set_show_sinking_contours(!m_gizmos.is_hiding_instances());
 
    // Orca: X-Ray replaces both shaded passes with a single one, driven from the opaque call, and
    // reuses the volume state (print volume, z range, clipping plane) set up above.
    if (_is_xray_view_active()) {
        if (type == GLVolumeCollection::ERenderType::Opaque)
            _render_xray_volumes();
        else
            _render_imex_ghosts_xray();
        m_camera_clipping_plane = ClippingPlane::ClipsNothing();
        return;
    }
 
    const bool realistic_mode = _is_realistic_view_enabled();
    const bool realistic_phong = wxGetApp().app_config != nullptr && wxGetApp().app_config->get_bool(SETTING_OPENGL_REALISTIC_PHONG);
    const std::string shader_name = (m_studio_lighting || (realistic_mode && realistic_phong)) ? "phong" : "gouraud";
    GLShaderProgram* shader = wxGetApp().get_shader(shader_name);
    if (shader == nullptr && shader_name != "gouraud")
        shader = wxGetApp().get_shader("gouraud");
    const bool studio = m_studio_lighting && shader != nullptr && shader->get_name() == "phong";
    ECanvasType canvas_type = this->m_canvas_type;
    bool                 partly_inside_enable = canvas_type == ECanvasType::CanvasAssembleView ? false : true;
    // The edited printer's per-extruder printable heights feed the object shader's
    // extruder_printable_heights uniform. Empty for single-extruder printers, so the shader flag stays
    // 0.0 and rendering is pixel-identical there (see GLVolumeCollection::render).
    auto printable_height_option = wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionFloatsNullable>("extruder_printable_height");
    std::vector<double>* printable_heights = printable_height_option ? &printable_height_option->values : nullptr;
    if (shader != nullptr) {
        shader->start_using();
 
        const bool phong_ssao = wxGetApp().app_config != nullptr && wxGetApp().app_config->get_bool(SETTING_OPENGL_PHONG_SSAO);
        shader->set_uniform("enable_ssao", phong_ssao);
        // Set on every use: the program is shared, so a canvas that leaves it unset would inherit
        // the last canvas's choice.
        shader->set_uniform("lighting_model", studio ? 1 : 0);
        shader->set_uniform("translucent_gloss", realistic_mode);
        if (studio) {
            const Transform3d& view = wxGetApp().plater()->get_camera().get_view_matrix();
            shader->set_uniform("world_up_eye", Vec3f((view.matrix().block<3, 3>(0, 0) * Vec3d::UnitZ()).cast<float>()));
        }
 
        // Object-on-object and self shadows: sample the depth map built in _render_shadow_map_pass().
        // shadow_intensity == 0 disables the effect entirely (unchanged behavior when off / unsupported).
        if (m_shadow_map_valid && m_shadow_map_texture_id != 0) {
            glsafe(::glActiveTexture(GL_TEXTURE4));
            glsafe(::glBindTexture(GL_TEXTURE_2D, m_shadow_map_texture_id));
            glsafe(::glActiveTexture(GL_TEXTURE0));
            shader->set_uniform("shadow_map", 4);
            shader->set_uniform("shadow_light_vp", m_shadow_light_vp);
            shader->set_uniform("shadow_map_texel", 1.0f / static_cast<float>(m_shadow_map_size));
            shader->set_uniform("shadow_intensity", 0.35f);
        }
        else
            shader->set_uniform("shadow_intensity", 0.0f);
        const std::optional<Vec3d> static_light = _static_light_dir_eye();
        shader->set_uniform("use_static_light", static_light.has_value());
        if (static_light.has_value())
            shader->set_uniform("static_light_dir", *static_light);
 
        const Size&   cvn_size = get_canvas_size();
        {
            const Camera& camera = wxGetApp().plater()->get_camera();
            shader->set_uniform("z_far", camera.get_far_z());
            shader->set_uniform("z_near", camera.get_near_z());
        }
        switch (type)
        {
        default:
        case GLVolumeCollection::ERenderType::Opaque:
        {
            GLGizmosManager& gm = get_gizmos_manager();
            if (dynamic_cast<GLGizmoPainterBase*>(gm.get_current()) == nullptr)
            {
                if (m_picking_enabled && m_layers_editing.is_enabled() && (m_layers_editing.last_object_id != -1) && (m_layers_editing.object_max_z() > 0.0f)) {
                    int object_id = m_layers_editing.last_object_id;
                const Camera& camera = wxGetApp().plater()->get_camera();
                m_volumes.render(type, false, camera.get_view_matrix(), camera.get_projection_matrix(), cvn_size, [object_id](const GLVolume& volume) {
                    // Which volume to paint without the layer height profile shader?
                    return volume.is_active && (volume.is_modifier || volume.composite_id.object_id != object_id);
                    });
                    m_layers_editing.render_volumes(*this, m_volumes);
                }
                else {
                    /*if (wxGetApp().plater()->is_wireframe_enabled()) {
                        if (wxGetApp().plater()->is_show_wireframe())
                            shader->set_uniform("show_wireframe", true);
                        else
                            shader->set_uniform("show_wireframe", false);
                    }*/
                    //BBS:add assemble view related logic
                    // do not cull backfaces to show broken geometry, if any
                const Camera& camera = wxGetApp().plater()->get_camera();
                    m_volumes.render(type, m_picking_enabled, camera.get_view_matrix(), camera.get_projection_matrix(), cvn_size, [this, canvas_type](const GLVolume& volume) {
                        if (canvas_type == ECanvasType::CanvasAssembleView) {
                            return !volume.is_modifier && !volume.is_wipe_tower;
                        }
                        else {
                            return (m_render_sla_auxiliaries || volume.composite_id.volume_id >= 0);
                        }
                        },
                        partly_inside_enable, printable_heights);
                }
            }
            else {
                // In case a painting gizmo is open, it should render the painted triangles
                // before transparent objects are rendered. Otherwise they would not be
                // visible when inside modifier meshes etc.
//                GLGizmosManager::EType type = gm.get_current_type();
                if (dynamic_cast<GLGizmoPainterBase*>(gm.get_current())) {
                    shader->stop_using();
                    gm.render_painter_gizmo();
                    shader->start_using();
                }
            }
 
            _render_section_view_caps();
            break;
        }
        case GLVolumeCollection::ERenderType::Transparent:
        {
            /*if (wxGetApp().plater()->is_wireframe_enabled()) {
                if (wxGetApp().plater()->is_show_wireframe())
                    shader->set_uniform("show_wireframe", true);
                else
                    shader->set_uniform("show_wireframe", false);
            }*/
            const Camera& camera = wxGetApp().plater()->get_camera();
            //BBS:add assemble view related logic
            m_volumes.render(type, false, camera.get_view_matrix(), camera.get_projection_matrix(), cvn_size, [canvas_type](const GLVolume& volume) {
                if (canvas_type == ECanvasType::CanvasAssembleView) {
                    return !volume.is_modifier;
                }
                else {
                    return true;
                }
                },
                partly_inside_enable, printable_heights);
            // IMEX ghosts are transparent and share the same shader/camera state;
            // render them right after the main transparent pass while the shader is still bound.
            _render_imex_ghosts();
            break;
        }
        }
 
        /*if (wxGetApp().plater()->is_wireframe_enabled()) {
            shader->set_uniform("show_wireframe", false);
        }*/
 
        if (m_shadow_map_valid && m_shadow_map_texture_id != 0) {
            glsafe(::glActiveTexture(GL_TEXTURE4));
            glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
            glsafe(::glActiveTexture(GL_TEXTURE0));
        }
        shader->set_uniform("use_static_light", false);
 
        shader->stop_using();
    }
 
    m_camera_clipping_plane = ClippingPlane::ClipsNothing();
}

References _get_volumes_clipping_plane(), _is_realistic_view_enabled(), _is_xray_view_active(), _render_imex_ghosts(), _render_imex_ghosts_xray(), _render_objects(), _render_section_view_caps(), _render_xray_volumes(), _static_light_dir_eye(), Slic3r::GUI::GLGizmoBase::apply_clipping_plane(), camera, CanvasAssembleView, Slic3r::Circle, Slic3r::GUI::ClippingPlane::ClipsNothing(), Slic3r::Convex, Slic3r::Custom, get_canvas_size(), Slic3r::GUI::GLGizmosManager::get_current(), get_gizmos_manager(), Slic3r::GLShaderProgram::get_name(), GL_DEPTH_TEST, GL_TEXTURE0, GL_TEXTURE4, GL_TEXTURE_2D, glActiveTexture, glBindTexture, glEnable, glsafe, Slic3r::BoundingBox3Base< PointType >::inflated(), is_layers_editing_enabled(), m_bed, m_camera_clipping_plane, m_canvas_type, m_clipping_planes, m_gizmos, m_layers_editing, m_model, m_picking_enabled, m_requires_check_outside_state, m_selection, m_shadow_light_vp, m_shadow_map_size, m_shadow_map_texture_id, m_shadow_map_valid, m_sinking_contours_enabled, m_studio_lighting, m_use_clipping_planes, m_volumes, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::GLVolumeCollection::Opaque, Slic3r::Rectangle, Slic3r::GUI::GLGizmosManager::render_painter_gizmo(), Slic3r::BuildVolume::SceneEpsilon, Slic3r::GLShaderProgram::set_uniform(), SETTING_OPENGL_PHONG_SSAO, SETTING_OPENGL_REALISTIC_PHONG, Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), Slic3r::GLVolumeCollection::Transparent, and Slic3r::unscaled().

Referenced by _render_objects(), and _render_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_orient_menu()

bool Slic3r::GUI::GLCanvas3D::_render_orient_menu	(	float	left,
		float	right,
		float	bottom,
		float	top )

private

{
    ImGuiWrapper* imgui = wxGetApp().imgui();
 
    auto canvas_w = float(get_canvas_size().get_width());
    auto canvas_h = float(get_canvas_size().get_height());
    //BBS: GUI refactor: move main toolbar to the right
    //original use center as {0.0}, and top is (canvas_h/2), bottom is (-canvas_h/2), also plus inv_camera
    //now change to left_up as {0,0}, and top is 0, bottom is canvas_h
#if BBS_TOOLBAR_ON_TOP
    const float x = (1 + left) * canvas_w / 2;
    ImGuiWrapper::push_toolbar_style(get_scale());
    imgui->set_next_window_pos(x, m_main_toolbar.get_height(), ImGuiCond_Always, 0.5f, 0.0f);
#else
    const float x = canvas_w - m_main_toolbar.get_width();
    const float y = 0.5f * canvas_h - top * float(wxGetApp().plater()->get_camera().get_zoom());
    imgui->set_next_window_pos(x, y, ImGuiCond_Always, 1.0f, 0.0f);
#endif
 
    imgui->begin(_L("Auto orientation options"), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse);
 
    OrientSettings settings = get_orient_settings();
    OrientSettings& settings_out = get_orient_settings();
 
    auto& appcfg = wxGetApp().app_config;
    PrinterTechnology ptech = current_printer_technology();
 
    bool settings_changed = false;
    float angle_min = 45.f;
    std::string angle_key = "overhang_angle", rot_key = "enable_rotation";
    std::string key_min_area = "min_area";
    std::string postfix = "_fff";
 
    if (ptech == ptSLA) {
        angle_min = 45.f;
        postfix = "_sla";
    }
 
 
    angle_key += postfix;
    rot_key += postfix;
 
    //if (imgui->slider_float(_L("Overhang Angle"), &settings.overhang_angle, angle_min, 90.0f, "%5.2f") || angle_min > settings.overhang_angle) {
    //    settings.overhang_angle = std::max(angle_min, settings.overhang_angle);
    //    settings_out.overhang_angle = settings.overhang_angle;
    //    appcfg->set("orient", angle_key, std::to_string(settings_out.overhang_angle));
    //    settings_changed = true;
    //}
 
    if (imgui->checkbox(_L("Enable rotation"), settings.enable_rotation)) {
        settings_out.enable_rotation = settings.enable_rotation;
        appcfg->set("orient", rot_key, settings_out.enable_rotation ? "1" : "0");
        settings_changed = true;
    }
 
    if (imgui->checkbox(_L("Optimize support interface area"), settings.min_area)) {
        settings_out.min_area = settings.min_area;
        appcfg->set("orient", key_min_area, settings_out.min_area ? "1" : "0");
        settings_changed = true;
    }
 
    ImGui::Separator();
 
    if (imgui->button(_L("Orient"))) {
        wxGetApp().plater()->set_prepare_state(Job::PREPARE_STATE_DEFAULT);
        wxGetApp().plater()->orient();
    }
 
    ImGui::SameLine();
 
    if (imgui->button(_L("Reset"))) {
        settings_out = OrientSettings{};
        settings_out.overhang_angle = 60.f;
        appcfg->set("orient", angle_key, std::to_string(settings_out.overhang_angle));
        appcfg->set("orient", rot_key, settings_out.enable_rotation ? "1" : "0");
        appcfg->set("orient", key_min_area, settings_out.min_area? "1" : "0");
        settings_changed = true;
    }
 
    imgui->end();
    ImGuiWrapper::pop_toolbar_style();
    return settings_changed;
}

References _L, Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::ImGuiWrapper::button(), Slic3r::GUI::ImGuiWrapper::checkbox(), current_printer_technology(), Slic3r::GUI::GLCanvas3D::OrientSettings::enable_rotation, Slic3r::GUI::ImGuiWrapper::end(), get_camera(), get_canvas_size(), get_orient_settings(), get_scale(), m_main_toolbar, Slic3r::GUI::GLCanvas3D::OrientSettings::min_area, Slic3r::GUI::GLCanvas3D::OrientSettings::overhang_angle, Slic3r::GUI::plater(), Slic3r::GUI::ImGuiWrapper::pop_toolbar_style(), Slic3r::GUI::Job::PREPARE_STATE_DEFAULT, Slic3r::ptSLA, Slic3r::GUI::ImGuiWrapper::push_toolbar_style(), and Slic3r::GUI::ImGuiWrapper::set_next_window_pos().

Here is the call graph for this function:

◆ _render_overlay_toolbars()

void Slic3r::GUI::GLCanvas3D::_render_overlay_toolbars ( )

private

{
    glsafe(::glDisable(GL_DEPTH_TEST));
 
    _render_separator_toolbar_right();
    _render_separator_toolbar_left();
    _render_main_toolbar();
    _render_collapse_toolbar();
    _render_assemble_view_toolbar();
    //BBS: GUI refactor: GLToolbar
    //move gizmos behind of main
    _render_gizmos_overlay();
 
    if (m_layers_editing.last_object_id >= 0 && m_layers_editing.object_max_z() > 0.0f)
        m_layers_editing.render_overlay(*this);
}

References _render_assemble_view_toolbar(), _render_collapse_toolbar(), _render_gizmos_overlay(), _render_main_toolbar(), _render_overlay_toolbars(), _render_separator_toolbar_left(), _render_separator_toolbar_right(), GL_DEPTH_TEST, glDisable, glsafe, and m_layers_editing.

Referenced by _render_frame(), and _render_overlay_toolbars().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_overlays()

void Slic3r::GUI::GLCanvas3D::_render_overlays ( )

private

{
    _check_and_update_toolbar_icon_scale();
 
    _render_assemble_control();
    _render_assemble_info();
 
    //BBS: GUI refactor: GLToolbar
    _render_imgui_select_plate_toolbar();
    _render_plate_switcher();
    _render_return_toolbar();
    // BBS
    //_render_view_toolbar();
    _render_paint_toolbar();
 
    // The options window of a pressed toolbar item (arrange).
    m_main_toolbar.render_item_windows(*this);
 
    m_gizmos.render_overlay_input_window();
 
    if (m_layers_editing.last_object_id >= 0 && m_layers_editing.object_max_z() > 0.0f)
        m_layers_editing.render_variable_layer_height_dialog(*this);
 
  auto curr_plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
    auto curr_print_seq = curr_plate->get_real_print_seq();
    const Print* print = fff_print();
    bool sequential_print = (curr_print_seq == PrintSequence::ByObject) || print->config().print_order == PrintOrder::AsObjectList;
    std::vector<const ModelInstance*> sorted_instances;
    if (sequential_print) {
        if (print) {
            for (const PrintObject *print_object : print->objects())
            {
                for (const PrintInstance &instance : print_object->instances())
                {
                    sorted_instances.emplace_back(instance.model_instance);
                }
            }
        }
        /*for (ModelObject* model_object : m_model->objects)
            for (ModelInstance* model_instance : model_object->instances) {
                sorted_instances.emplace_back(model_instance);
            }*/
    }
    m_labels.render(sorted_instances);
    m_center_of_mass.render_details(*this);
 
    _render_3d_navigator();
 
    _render_canvas_toolbar();
 
    // Recorded by the scene pass, which a reused frame skips.
    wxGetApp().plater()->get_partplate_list().render_hover_tooltip();
}

References _check_and_update_toolbar_icon_scale(), _render_3d_navigator(), _render_assemble_control(), _render_assemble_info(), _render_canvas_toolbar(), _render_imgui_select_plate_toolbar(), _render_overlays(), _render_paint_toolbar(), _render_plate_switcher(), _render_return_toolbar(), Slic3r::AsObjectList, Slic3r::ByObject, Slic3r::Print::config(), fff_print(), m_center_of_mass, m_gizmos, m_labels, m_layers_editing, m_main_toolbar, and Slic3r::Print::objects().

Referenced by _render_frame(), and _render_overlays().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_paint_toolbar()

void Slic3r::GUI::GLCanvas3D::_render_paint_toolbar ( ) const

private

{
    if (m_canvas_type != ECanvasType::CanvasAssembleView)
        return;
#if ENABLE_RETINA_GL
    float f_scale = m_retina_helper->get_scale_factor();
#else
    float f_scale = 1.0f;
#endif
    int em_unit = wxGetApp().em_unit() / 10;
 
    std::vector<std::string> colors = wxGetApp().plater()->get_extruder_colors_from_plater_config();
    int extruder_num = colors.size();
    std::vector<std::string> filament_text_first_line;
    std::vector<std::string> filament_text_second_line;
    {
        auto preset_bundle = wxGetApp().preset_bundle;
        for (auto filament_name : preset_bundle->filament_presets) {
            for (auto iter = preset_bundle->filaments.lbegin(); iter != preset_bundle->filaments.end(); iter++) {
                if (filament_name.compare(iter->name) == 0) {
                    std::string display_filament_type;
                    iter->config.get_filament_type(display_filament_type);
                    auto pos = display_filament_type.find(' ');
                    if (pos != std::string::npos) {
                        filament_text_first_line.push_back(display_filament_type.substr(0, pos));
                        filament_text_second_line.push_back(display_filament_type.substr(pos + 1));
                    }
                    else {
                        filament_text_first_line.push_back(display_filament_type);
                        filament_text_second_line.push_back("");
                    }
                }
            }
        }
    }
    // ORCA: the loop above only labels a slot whose preset was found in the preset collection,
    // while the render loop below iterates extruder_num. Pad the label arrays so a slot without a
    // matching preset cannot index past them; a garbage std::string crashes ImGui::CalcTextSize.
    while (int(filament_text_first_line.size()) < extruder_num) {
        filament_text_first_line.emplace_back();
        filament_text_second_line.emplace_back();
    }
 
    ImGuiWrapper& imgui = *wxGetApp().imgui();
    const float canvas_w = float(get_canvas_size().get_width());
    const ImVec2 button_size = ImVec2(64.0f, 48.0f) * f_scale * em_unit;
    const float spacing = 4.0f * em_unit * f_scale;
    const float return_button_margin = 130.0f * em_unit * f_scale;
 
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(spacing, spacing));
    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0);
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(spacing, 0));
    ImGui::PushStyleColor(ImGuiCol_WindowBg, m_is_dark ? ImGuiWrapper::COL_TOOLBAR_BG_DARK : ImGuiWrapper::COL_TOOLBAR_BG); // ORCA Toolbar color
 
    imgui.set_next_window_pos(0.5f * canvas_w, 0, ImGuiCond_Always, 0.5f, 0.0f);
    float constraint_window_width = canvas_w - 2 * return_button_margin;
    ImGui::SetNextWindowSizeConstraints({ 0, 0 }, { constraint_window_width, FLT_MAX });
    imgui.begin(_L("Paint Toolbar"), ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse);
 
    const float cursor_y = ImGui::GetCursorPosY();
    const ImVec2 arrow_button_size = ImVec2(0.375f * button_size.x, ImGui::GetWindowHeight());
    const ImRect left_arrow_button = ImRect(ImGui::GetCurrentWindow()->Pos, ImGui::GetCurrentWindow()->Pos + arrow_button_size);
    const ImRect right_arrow_button = ImRect(ImGui::GetCurrentWindow()->Pos + ImGui::GetWindowSize() - arrow_button_size, ImGui::GetCurrentWindow()->Pos + ImGui::GetWindowSize());
    ImU32 left_arrow_button_color = IM_COL32(0, 0, 0, 0.4f * 255);
    ImU32 right_arrow_button_color = IM_COL32(0, 0, 0, 0.4f * 255);
    ImU32 arrow_color = IM_COL32(255, 255, 255, 255);
    ImDrawList* draw_list = ImGui::GetWindowDrawList();
    ImGuiContext& context = *GImGui;
    bool disabled = !wxGetApp().plater()->can_fillcolor();
    ColorRGBA rgba;
 
    // Gradient mixed filaments fade over Z, so their swatch is drawn as that fade rather than
    // the single blended colour in `colors`. Every other slot's ramp is empty.
    const auto& gradient_ramps = wxGetApp().plater()->get_filament_gradient_ramps();
 
    for (int i = 0; i < extruder_num; i++) {
        if (i > 0)
            ImGui::SameLine();
        decode_color(colors[i], rgba);
        ImGui::PushStyleColor(ImGuiCol_Button, ImGuiWrapper::to_ImVec4(rgba));
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImGuiWrapper::to_ImVec4(rgba));
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImGuiWrapper::to_ImVec4(rgba));
        if (disabled)
            ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
        if (ImGui::Button(("##filament_button" + std::to_string(i)).c_str(), button_size)) {
            if (!ImGui::IsMouseHoveringRect(left_arrow_button.Min, left_arrow_button.Max) && !ImGui::IsMouseHoveringRect(right_arrow_button.Min, right_arrow_button.Max))
                wxPostEvent(m_canvas, IntEvent(EVT_GLTOOLBAR_FILLCOLOR, i + 1));
        }
        if (i < (int) gradient_ramps.size() && !gradient_ramps[i].empty())
            ImGuiWrapper::draw_gradient_ramp(draw_list, ImGui::GetItemRectMin(), ImGui::GetItemRectMax(), gradient_ramps[i]);
        if (ImGui::IsItemHovered() && i < 9) {
            if (!ImGui::IsMouseHoveringRect(left_arrow_button.Min, left_arrow_button.Max) && !ImGui::IsMouseHoveringRect(right_arrow_button.Min, right_arrow_button.Max)) {
                ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, { 20.0f * f_scale, 10.0f * f_scale });
                ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 3.0f * f_scale);
                imgui.tooltip(wxString::Format(_L("Shortcut Key %d"), i + 1), ImGui::GetFontSize() * 20.0f);
                ImGui::PopStyleVar(2);
            }
        }
        ImGui::PopStyleColor(3);
        if (disabled)
            ImGui::PopItemFlag();
    }
 
    const float text_offset_y = 4.0f * em_unit * f_scale;
    for (int i = 0; i < extruder_num; i++) {
        // A gradient slot's swatch shows its fade instead of the blended colour in `colors`, so the
        // labels take their contrast from the colour printed at the middle of the fade they sit on.
        if (i < (int) gradient_ramps.size() && !gradient_ramps[i].empty()) {
            const wxColour& c = gradient_ramps[i][gradient_ramps[i].size() / 2];
            rgba = ColorRGBA(c.Red(), c.Green(), c.Blue(), c.Alpha());
        } else
            decode_color(colors[i], rgba);
        float  gray       = 0.299 * rgba.r_uchar() + 0.587 * rgba.g_uchar() + 0.114 * rgba.b_uchar();
        ImVec4 text_color = gray < 80 ? ImVec4(1.0f, 1.0f, 1.0f, 1.0f) : ImVec4(0, 0, 0, 1.0f);
 
        imgui.push_bold_font();
        ImVec2 number_label_size = ImGui::CalcTextSize(std::to_string(i + 1).c_str());
        ImGui::SetCursorPosY(cursor_y + text_offset_y);
        ImGui::SetCursorPosX(spacing + i * (spacing + button_size.x) + (button_size.x - number_label_size.x) / 2);
        ImGui::TextColored(text_color, "%s", std::to_string(i + 1).c_str());
        imgui.pop_bold_font();
 
        ImVec2 filament_first_line_label_size = ImGui::CalcTextSize(filament_text_first_line[i].c_str());
        ImGui::SetCursorPosY(cursor_y + text_offset_y + number_label_size.y);
        ImGui::SetCursorPosX(spacing + i * (spacing + button_size.x) + (button_size.x - filament_first_line_label_size.x) / 2);
        ImGui::TextColored(text_color, "%s", filament_text_first_line[i].c_str());
 
        ImVec2 filament_second_line_label_size = ImGui::CalcTextSize(filament_text_second_line[i].c_str());
        ImGui::SetCursorPosY(cursor_y + text_offset_y + number_label_size.y + filament_first_line_label_size.y);
        ImGui::SetCursorPosX(spacing + i * (spacing + button_size.x) + (button_size.x - filament_second_line_label_size.x) / 2);
        ImGui::TextColored(text_color, "%s", filament_text_second_line[i].c_str());
    }
 
    if (ImGui::GetWindowWidth() == constraint_window_width) {
        if (ImGui::IsMouseHoveringRect(left_arrow_button.Min, left_arrow_button.Max)) {
            left_arrow_button_color = IM_COL32(0, 0, 0, 0.64f * 255);
            if (context.IO.MouseClicked[ImGuiMouseButton_Left]) {
                ImGui::SetScrollX(ImGui::GetScrollX() - button_size.x);
                imgui.set_requires_extra_frame();
            }
        }
        draw_list->AddRectFilled(left_arrow_button.Min, left_arrow_button.Max, left_arrow_button_color);
        ImGui::BBLRenderArrow(draw_list, left_arrow_button.GetCenter() - ImVec2(draw_list->_Data->FontSize, draw_list->_Data->FontSize) * 0.5f, arrow_color, ImGuiDir_Left, 2.0f);
 
        if (ImGui::IsMouseHoveringRect(right_arrow_button.Min, right_arrow_button.Max)) {
            right_arrow_button_color = IM_COL32(0, 0, 0, 0.64f * 255);
            if (context.IO.MouseClicked[ImGuiMouseButton_Left]) {
                ImGui::SetScrollX(ImGui::GetScrollX() + button_size.x);
                imgui.set_requires_extra_frame();
            }
        }
        draw_list->AddRectFilled(right_arrow_button.Min, right_arrow_button.Max, right_arrow_button_color);
        ImGui::BBLRenderArrow(draw_list, right_arrow_button.GetCenter() - ImVec2(draw_list->_Data->FontSize, draw_list->_Data->FontSize) * 0.5f, arrow_color, ImGuiDir_Right, 2.0f);
    }
 
    m_paint_toolbar_width = (ImGui::GetWindowWidth() + 50.0f * em_unit * f_scale);
    imgui.end();
    ImGui::PopStyleVar(3);
    ImGui::PopStyleColor();
}

Referenced by _render_overlays(), and _render_paint_toolbar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_plane()

void Slic3r::GUI::GLCanvas3D::_render_plane ( ) const

private

{
    ;//TODO render assemble plane
}

References _render_plane().

Referenced by _render_plane(), and _render_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_plate_switcher()

void Slic3r::GUI::GLCanvas3D::_render_plate_switcher ( )

private

{
    Plater*        plater      = wxGetApp().plater();
    PartPlateList& plate_list  = plater->get_partplate_list();
    const int      plate_count = plate_list.get_plate_count();
    if (!_hides_inactive_plates() || plate_count < 2 || m_gizmos.get_current_type() != GLGizmosManager::Undefined)
        return;
 
    // The thumbnails are the ones of the Preview plate toolbar.
    const unsigned version = plater->plate_toolbar_image_version();
    if (m_plate_switcher_version != version || m_plate_switcher_items.size() != size_t(plate_count)) {
        // Only the current plate is edited here; the others are redrawn when their thumbnails go invalid.
        for (int i = 0; i < plate_count && !plater->is_gcode_3mf(); ++i)
            plater->update_plate_thumbnails(i, i == plate_list.get_curr_plate_index());
        m_plate_switcher_items.clear();
        for (int i = 0; i < plate_count; ++i) {
            m_plate_switcher_items.push_back(std::make_unique<IMToolbarItem>());
            m_plate_switcher_items.back()->set_thumbnail(plate_list.get_plate(i)->thumbnail_data);
        }
        m_plate_switcher_version = version;
    }
 
    float sc = get_scale();
#ifdef WIN32
    sc *= (float) get_dpi_for_window(wxGetApp().GetTopWindow()) / (float) DPI_DEFAULT;
#endif // WIN32
 
    ImGuiWrapper& imgui     = *wxGetApp().imgui();
    const ImVec2  btn_size  = ImVec2(72.f, 72.f) * sc;
    const ImVec2  padding   = ImVec2(8.f, 8.f) * sc;
    const float   spacing   = 8.f * sc;
    const float   rounding  = 4.f * sc;
    const float   scrollbar = PLATE_TOOLBAR_SCROLLBAR * sc;
    const float   top       = std::max(m_main_toolbar.get_height(), m_gizmos.get_scaled_total_height()) + CANVAS_TOOLBAR_MARGIN * sc;
    const float   content_h = plate_count * (btn_size.y + spacing) - spacing + 2.f * padding.y;
    const float   max_h     = std::max(btn_size.y + 2.f * padding.y, float(get_canvas_size().get_height()) - top - (canvas_corner_height() + CANVAS_TOOLBAR_MARGIN) * sc);
    // As in the Preview plate toolbar, the scrollbar shows only while the mouse is over the column.
    const bool    scroll    = m_plate_switcher_scrollbar && content_h > max_h;
 
    const ImVec4 text_color  = m_is_dark ? ImVec4(.9f, .9f, .9f, 1.f) : ImVec4(.3f, .3f, .3f, 1.f);
    const ImVec4 empty_color = ImVec4(text_color.x, text_color.y, text_color.z, .45f);
    const ImVec4 hover       = plate_toolbar_hover_color(m_is_dark);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, padding);
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(spacing, spacing));
    // Concentric with the thumbnails; tighter around the scrollbar, as in the Preview plate toolbar.
    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, scroll ? 6.f * sc : rounding + padding.x);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.f);
    ImGui::PushStyleColor(ImGuiCol_WindowBg, m_is_dark ? ImVec4(.13f, .13f, .15f, .5f) : ImVec4(1.f, 1.f, 1.f, .7f));
    push_plate_toolbar_scrollbar_style(m_is_dark, scrollbar);
 
    imgui.set_next_window_pos(CANVAS_TOOLBAR_MARGIN * sc, top, ImGuiCond_Always, 0.f, 0.f);
    imgui.set_next_window_size(btn_size.x + 2.f * padding.x + (scroll ? scrollbar : 0.f), std::min(content_h, max_h), ImGuiCond_Always);
    imgui.begin(std::string("##PlateSwitcher"), ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar |
                                                ImGuiWindowFlags_NoCollapse | (scroll ? 0 : ImGuiWindowFlags_NoScrollbar));
 
    const int curr_plate = plate_list.get_curr_plate_index();
    ImDrawList*  draw_list = ImGui::GetWindowDrawList();
    const ImU32  plate_bg  = m_is_dark ? IM_COL32(255, 255, 255, 10) : IM_COL32(0, 0, 0, 10);
    const ImU32  plate_dim = m_is_dark ? IM_COL32(30, 30, 30, 100) : IM_COL32(0, 0, 0, 50);
    for (int i = 0; i < plate_count; ++i) {
        PartPlate* plate   = plate_list.get_plate(i);
        const bool current = i == curr_plate;
        const ImVec2 pos   = ImGui::GetCursorScreenPos();
        ImGui::PushID(i);
        const bool clicked = ImGui::InvisibleButton("##plate", btn_size);
        ImGui::PopID();
        const bool hovered = ImGui::IsItemHovered();
 
        draw_list->AddRectFilled(pos, pos + btn_size, plate_bg, rounding);
        if (ImTextureID texture = m_plate_switcher_items[i]->texture_id)
            draw_list->AddImageRounded(texture, pos, pos + btn_size, ImVec2(0.f, 1.f), ImVec2(1.f, 0.f), IM_COL32_WHITE, rounding);
        if (plate->empty())
            draw_list->AddRectFilled(pos, pos + btn_size, plate_dim, rounding);
        if (current || hovered) {
            const float border = 2.f * sc;
            draw_list->AddRect(pos - ImVec2(border, border) * .5f, pos + btn_size + ImVec2(border, border) * .5f,
                               ImGui::GetColorU32(current ? (hovered ? ImGuiWrapper::COL_ORCA_HOVER : ImGuiWrapper::COL_ORCA) : hover),
                               rounding + border * .5f, 0, border);
        }
        draw_list->AddText(pos + ImVec2(4.f, 2.f) * sc, ImGui::GetColorU32(plate->empty() ? empty_color : text_color), std::to_string(i + 1).c_str());
 
        if (clicked && !current)
            plater->CallAfter([i]() {
                wxGetApp().plater()->select_plate(i);
                wxGetApp().plater()->deselect_all();
            });
        if (hovered) {
            const std::string name = plate->get_plate_name();
            imgui.tooltip(_u8L("Plate") + " " + std::to_string(i + 1) + (name.empty() ? "" : " (" + name + ")"), ImGui::GetFontSize() * 20.f);
        }
    }
 
    m_plate_switcher_scrollbar = plate_toolbar_keeps_scrollbar(scroll, scrollbar);
    imgui.end();
    ImGui::PopStyleColor(5);
    ImGui::PopStyleVar(5);
}

References _hides_inactive_plates(), _render_plate_switcher(), _u8L, Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::canvas_corner_height(), Slic3r::GUI::CANVAS_TOOLBAR_MARGIN, Slic3r::GUI::ImGuiWrapper::COL_ORCA, Slic3r::GUI::ImGuiWrapper::COL_ORCA_HOVER, Slic3r::GUI::DPI_DEFAULT, Slic3r::GUI::PartPlate::empty(), Slic3r::GUI::ImGuiWrapper::end(), get_canvas_size(), Slic3r::GUI::PartPlateList::get_curr_plate_index(), Slic3r::GUI::get_dpi_for_window(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GUI::PartPlateList::get_plate_count(), Slic3r::GUI::PartPlate::get_plate_name(), get_scale(), m_gizmos, m_is_dark, m_main_toolbar, m_plate_switcher_items, m_plate_switcher_scrollbar, m_plate_switcher_version, Slic3r::GUI::plate_toolbar_hover_color(), Slic3r::GUI::plate_toolbar_keeps_scrollbar(), Slic3r::GUI::PLATE_TOOLBAR_SCROLLBAR, Slic3r::GUI::plater(), Slic3r::GUI::push_plate_toolbar_scrollbar_style(), Slic3r::GUI::ImGuiWrapper::set_next_window_pos(), Slic3r::GUI::ImGuiWrapper::set_next_window_size(), text_color(), Slic3r::GUI::PartPlate::thumbnail_data, Slic3r::GUI::ImGuiWrapper::tooltip(), and Slic3r::GUI::GLGizmosManager::Undefined.

Referenced by _render_overlays(), and _render_plate_switcher().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_platelist()

void Slic3r::GUI::GLCanvas3D::_render_platelist	(	const Transform3d &	view_matrix,
		const Transform3d &	projection_matrix,
		bool	bottom,
		bool	only_current,
		bool	only_body = false,
		int	hover_id = -1,
		bool	render_cali = false,
		bool	show_grid = true )

private

{
    PartPlateList& plate_list = wxGetApp().plater()->get_partplate_list();
    // Design tab: its bed stays at the printer bed's home whichever plate is current, so the
    // current plate's exclude areas are moved from that plate onto it.
    PartPlate* curr_plate = plate_list.get_curr_plate();
    const Transform3d plate_view_matrix = m_design_canvas && curr_plate != nullptr ?
        Transform3d(view_matrix * Geometry::translation_transform(-curr_plate->get_origin())) : view_matrix;
    plate_list.render(plate_view_matrix, projection_matrix, bottom, only_current, only_body, hover_id, render_cali, show_grid, !m_plate_chrome_enabled, _hides_inactive_plates());
}

References _hides_inactive_plates(), _render_platelist(), Slic3r::GUI::PartPlateList::get_curr_plate(), Slic3r::GUI::PartPlate::get_origin(), m_design_canvas, m_plate_chrome_enabled, Slic3r::GUI::PartPlateList::render(), and Slic3r::Geometry::translation_transform().

Referenced by _render_platelist(), and _render_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_return_toolbar()

void Slic3r::GUI::GLCanvas3D::_render_return_toolbar ( ) const

private

{
    if (!m_return_toolbar.is_enabled())
        return;
 
    float font_size = ImGui::GetFontSize();
    ImVec2 real_size = ImVec2(font_size * 4, font_size * 1.7);
    ImVec2 button_icon_size = ImVec2(font_size * .55, font_size * 1.1); // ORCA
 
    ImGuiWrapper& imgui = *wxGetApp().imgui();
    Size cnv_size = get_canvas_size();
    auto canvas_w = float(cnv_size.get_width());
    auto canvas_h = float(cnv_size.get_height());
    float window_width = real_size.x + button_icon_size.x + imgui.scaled(2.0f);
    float window_height = button_icon_size.y + imgui.scaled(2.0f);
    float window_pos_x = 30.0f + (is_collapse_toolbar_on_left() ? (get_collapse_toolbar_width() + 5.f) : 0);
    float window_pos_y = 14.0f;
 
    imgui.set_next_window_pos(window_pos_x, window_pos_y, ImGuiCond_Always, 0, 0);
#ifdef __WINDOWS__
    imgui.set_next_window_size(window_width, window_height, ImGuiCond_Always);
#endif
 
    ImVec4 fg_color = m_is_dark ? ImVec4(1.f, 1.f, 1.f, 0.88f) : ImVec4(50 / 255.f, 58 / 255.f, 61 / 255.f, 1.f);
    ImVec4 bg_color = m_is_dark ? ImGuiWrapper::COL_TOOLBAR_BG_DARK : ImGuiWrapper::COL_TOOLBAR_BG;
    ImVec4 bg_color_hover = bg_color +  (m_is_dark ? ImVec4(.03f, .03f, .03f, 0) : ImVec4(-.02f, -.02f, -.02f, 0));
 
    ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 18.0f);
    ImGui::PushStyleColor(ImGuiCol_Button,        bg_color); // ORCA Toolbar color
    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, bg_color_hover);
    ImGui::PushStyleColor(ImGuiCol_ButtonActive,  bg_color);
    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.0f, 0.0f, 0.0f, 0.0f));
    ImGui::PushStyleColor(ImGuiCol_Text, fg_color);
 
    imgui.begin(_L("Assembly Return"), ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoBackground
        | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse);
 
    float button_width = 20;
    float button_height = 20;
    ImVec2 size = ImVec2(button_width, button_height); // Size of the image we want to make visible
    ImVec2 uv0 = ImVec2(0.0f, 0.0f);
    ImVec2 uv1 = ImVec2(1.0f, 1.0f);
 
    ImVec4 bg_col = ImVec4(0.0f, 0.0f, 0.0f, 0.0f);
    ImVec4 tint_col = fg_color; // icon color
    ImVec2 margin = ImVec2(10.0f, 5.0f);
 
    if (ImGui::ImageTextButton(real_size,_utf8(L("Return")).c_str(), m_return_toolbar.get_return_texture_id(), button_icon_size, uv0, uv1, -1, bg_col, tint_col, margin)) {
        const_cast<GLGizmosManager*>(&m_gizmos)->reset_all_states();
        if (m_canvas != nullptr && !wxGetApp().is_closing()) {
            m_canvas->CallAfter([]() {
                auto& app = wxGetApp();
                if (app.is_closing())
                    return;
 
                auto* plater = app.plater();
                if (plater == nullptr)
                    return;
 
                plater->select_view_3D("3D");
 
                auto* view3d_canvas = plater->get_view3D_canvas3D();
                if (view3d_canvas == nullptr)
                    return;
 
                view3d_canvas->get_gizmos_manager().reset_all_states();
                view3d_canvas->reload_scene(true);
            });
        }
    }
    ImGui::PopStyleColor(5);
    ImGui::PopStyleVar(1);
 
    imgui.end();
}

References _L, _render_return_toolbar(), _utf8, Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::ImGuiWrapper::COL_TOOLBAR_BG, Slic3r::GUI::ImGuiWrapper::COL_TOOLBAR_BG_DARK, Slic3r::GUI::ImGuiWrapper::end(), get_canvas_size(), get_collapse_toolbar_width(), Slic3r::GUI::Size::get_height(), Slic3r::GUI::Size::get_width(), is_collapse_toolbar_on_left(), L, m_canvas, m_gizmos, m_is_dark, m_return_toolbar, Slic3r::GUI::plater(), Slic3r::GUI::ImGuiWrapper::scaled(), Slic3r::GUI::ImGuiWrapper::set_next_window_pos(), and Slic3r::GUI::ImGuiWrapper::set_next_window_size().

Referenced by _render_overlays(), and _render_return_toolbar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_scene()

void Slic3r::GUI::GLCanvas3D::_render_scene	(	const Camera &	camera,
		const Size &	cnv_size )

private

{
    // Recorded by PartPlate::render_icons() below, when it runs.
    wxGetApp().plater()->get_partplate_list().clear_hover_tooltip();
    glsafe(::glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
    // Invalidate the shadow map each frame; the View3D and Preview paths below rebuild it. This
    // keeps the Assemble canvas from sampling a stale map with an outdated light matrix.
    m_shadow_map_valid = false;
    _render_background();
 
    //BBS add partplater rendering logic
    bool only_current = false, only_body = false;
    const bool show_bed = is_bed_visible();
    bool show_grid = true;
    GLGizmosManager::EType gizmo_type = m_gizmos.get_current_type();
    if (!m_main_toolbar.is_enabled()) {
        //only_body = true;
        only_current = true;
    }
    else if (gizmo_type == GLGizmosManager::BrimEars && !camera.is_looking_downward())
        show_grid = false;
    if (m_design_canvas)
        // Design tab: the plate grid is generated from the plate's front-left corner, so it
        // floats mid-cell under the modeling-origin triad. Suppress it here; a CAD grid centred
        // on the origin is rendered in its place (see _render_cad_grid).
        show_grid = false;
 
    /* view3D render*/
    int hover_id = (m_hover_plate_idxs.size() > 0)?m_hover_plate_idxs.front():-1;
    if (m_canvas_type == ECanvasType::CanvasView3D) {
        // m_show_bed gates the plate list too: hiding the bed but leaving its grid and outline
        // floating would read as a rendering fault rather than a deliberate view option.
        if (show_bed) {
            bool show_axes = m_show_world_axes;
#ifdef SLIC3R_CAD
            // Design tab: while its reference planes are up they draw their own axes from the modeling
            // origin, where the bed's triad would otherwise sit on top of them.
            show_axes = show_axes && !(m_design_sketch_tool != nullptr && m_design_sketch_tool->draws_reference_axes());
#endif
            _render_bed(camera.get_view_matrix(), camera.get_projection_matrix(), !camera.is_looking_downward(), show_axes);
        }
        m_frame_profiler.mark("bed");
        // Exception: the painting gizmos hide the bed mesh on purpose and draw the plate instead,
        // so there the plate list is the only bed reference in the scene.
        if (show_bed || _is_below_plate_view_active()) //BBS: add outline logic
            _render_platelist(camera.get_view_matrix(), camera.get_projection_matrix(), !camera.is_looking_downward(), only_current, only_body, hover_id, true, show_grid);
        if (m_design_canvas && show_bed)
            // Design tab: replace the plate's corner-origin grid with the origin-centred CAD grid.
            _render_cad_grid(camera.get_view_matrix(), camera.get_projection_matrix());
        m_frame_profiler.mark("plates");
        //BBS: add outline logic
        // Depth pass for object-on-object and self shadows; consumed by the gouraud shader below.
        _render_shadows(camera.get_view_matrix(), camera.get_projection_matrix());
        m_frame_profiler.mark("shadows");
        _render_objects(GLVolumeCollection::ERenderType::Opaque, !m_gizmos.is_running());
        _render_below_plate_volumes();
        m_frame_profiler.mark("objects");
        // Collision previews follow the same visibility rule as the bed.
        const bool show_exclusion_intersections = m_show_bed &&
            (!m_main_toolbar.is_enabled() ||
             (gizmo_type != GLGizmosManager::FdmSupports && gizmo_type != GLGizmosManager::Seam &&
              gizmo_type != GLGizmosManager::MmSegmentation && gizmo_type != GLGizmosManager::FuzzySkin));
        if (show_exclusion_intersections)
            wxGetApp().plater()->get_partplate_list().render_exclusion_volume_intersections(
                camera.get_view_matrix(), camera.get_projection_matrix());
        _render_sla_slices();
        _render_selection();
        _render_objects(GLVolumeCollection::ERenderType::Transparent, !m_gizmos.is_running());
        _render_wireframe_overlay();
        m_frame_profiler.mark("transparent");
    }
    /* preview render */
    else if (m_canvas_type == ECanvasType::CanvasPreview && m_render_preview) {
        // Before the shadow pass, so the cut away part casts no shadow.
        m_gcode_viewer.set_clipping_plane(_get_section_view_plane());
        _render_objects(GLVolumeCollection::ERenderType::Opaque, !m_gizmos.is_running());
        _render_sla_slices();
        _render_selection();
        m_frame_profiler.mark("objects");
        _render_bed(camera.get_view_matrix(), camera.get_projection_matrix(), !camera.is_looking_downward(), m_show_world_axes);
        m_frame_profiler.mark("bed");
        _render_platelist(camera.get_view_matrix(), camera.get_projection_matrix(), !camera.is_looking_downward(), only_current, true, hover_id);
        m_frame_profiler.mark("plates");
        // Realistic view: the print casts a shadow onto the plate here as it does in View3D.
        _render_shadows(camera.get_view_matrix(), camera.get_projection_matrix());
        m_frame_profiler.mark("shadows");
        // BBS: GUI refactor: add canvas size as parameters
        _render_gcode(cnv_size.get_width(), cnv_size.get_height());
        m_frame_profiler.mark("gcode");
    }
    /* assemble render*/
    else if (m_canvas_type == ECanvasType::CanvasAssembleView) {
        //BBS: add outline logic
        //if (m_show_world_axes) {
        //    m_axes.render();
        //}
        _render_objects(GLVolumeCollection::ERenderType::Opaque, !m_gizmos.is_running());
        _render_selection();
        //_render_bed(camera.get_view_matrix(), camera.get_projection_matrix(), !camera.is_looking_downward(), show_axes);
        _render_plane();
        //BBS: add outline logic insteadof selection under assemble view
        //_render_selection();
        // BBS: add outline logic
        _render_objects(GLVolumeCollection::ERenderType::Transparent, !m_gizmos.is_running());
        _render_wireframe_overlay();
        m_frame_profiler.mark("objects");
    }
 
    _render_sequential_clearance();
#if ENABLE_RENDER_SELECTION_CENTER
    _render_selection_center();
#endif // ENABLE_RENDER_SELECTION_CENTER
    // sidebar hints need to be rendered before the gizmos because the depth buffer
    // could be invalidated by the following gizmo render methods
    _render_selection_sidebar_hints();
    _render_current_gizmo();
 
#if ENABLE_RAYCAST_PICKING_DEBUG
    if (m_picking_enabled && !m_mouse.dragging && !m_gizmos.is_dragging() && !m_rectangle_selection.is_dragging())
        m_scene_raycaster.render_hit(camera);
#endif // ENABLE_RAYCAST_PICKING_DEBUG
 
#if ENABLE_SHOW_CAMERA_TARGET
    _render_camera_target();
#endif // ENABLE_SHOW_CAMERA_TARGET
 
    if (m_picking_enabled && m_rectangle_selection.is_dragging())
        m_rectangle_selection.render(*this);
    m_frame_profiler.mark("gizmos");
 
    if (_is_ssao_enabled()) {
        _render_ssao_pass(static_cast<unsigned int>(cnv_size.get_width()), static_cast<unsigned int>(cnv_size.get_height()));
        m_frame_profiler.mark("ssao");
    }
 
    if (m_canvas_type == ECanvasType::CanvasPreview && m_render_preview) {
        _render_gcode_translucent(cnv_size.get_width(), cnv_size.get_height());
        m_frame_profiler.mark("gcode translucent");
    }
 
    // After the occlusion pass, which would shade it as the surface behind it.
    m_center_of_mass.render(*this);
 
    if (_is_fxaa_enabled()) {
        _render_fxaa_pass(static_cast<unsigned int>(cnv_size.get_width()), static_cast<unsigned int>(cnv_size.get_height()));
        m_frame_profiler.mark("fxaa");
    }
 
    // Design tab: interactive 2D sketch overlay, drawn over the scene but
    // beneath the UI overlays (toolbars, labels).
#ifdef SLIC3R_CAD
    if (m_design_sketch_tool != nullptr && m_design_sketch_tool->has_display())
        m_design_sketch_tool->render(*this);
#endif
 
    _capture_scene_cache(camera);
    m_frame_profiler.mark("cache");
}

References _capture_scene_cache(), _get_section_view_plane(), _is_below_plate_view_active(), _is_fxaa_enabled(), _is_ssao_enabled(), _render_background(), _render_bed(), _render_below_plate_volumes(), _render_cad_grid(), _render_current_gizmo(), _render_fxaa_pass(), _render_gcode(), _render_gcode_translucent(), _render_objects(), _render_plane(), _render_platelist(), _render_selection(), _render_selection_sidebar_hints(), _render_sequential_clearance(), _render_shadows(), _render_sla_slices(), _render_ssao_pass(), _render_wireframe_overlay(), Slic3r::GUI::GLGizmosManager::BrimEars, camera, CanvasAssembleView, CanvasPreview, CanvasView3D, Slic3r::GUI::GLGizmosManager::FdmSupports, Slic3r::GUI::GLGizmosManager::FuzzySkin, Slic3r::GUI::Size::get_height(), Slic3r::GUI::Size::get_width(), GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, glClear, glsafe, is_bed_visible(), m_canvas_type, m_center_of_mass, m_design_canvas, m_frame_profiler, m_gcode_viewer, m_gizmos, m_hover_plate_idxs, m_main_toolbar, m_mouse, m_picking_enabled, m_rectangle_selection, m_render_preview, m_scene_raycaster, m_shadow_map_valid, m_show_bed, m_show_world_axes, Slic3r::GUI::GLGizmosManager::MmSegmentation, Slic3r::GLVolumeCollection::Opaque, Slic3r::GUI::GLGizmosManager::Seam, and Slic3r::GLVolumeCollection::Transparent.

Referenced by _render_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_section_view_caps()

void Slic3r::GUI::GLCanvas3D::_render_section_view_caps ( )

private

{
    // A gizmo with its own clipper draws its own cut faces.
    const ClippingPlane plane = m_gizmos.get_clipping_plane().has_value() ? ClippingPlane::ClipsNothing() : _get_section_view_plane();
    if (!plane.is_active() || m_model == nullptr) {
        m_section_view_caps.clear();
        return;
    }
 
    // Last frame's clippers are reused, so unchanged cuts are not recomputed.
    std::map<const GLVolume*, MeshClipper> caps;
    for (const GLVolume* volume : m_volumes.volumes) {
        if (!volume->is_active || volume->is_modifier || volume->is_wipe_tower || volume->volume_idx() < 0 ||
            volume->object_idx() >= int(m_model->objects.size()))
            continue;
        const ModelObject* object = m_model->objects[volume->object_idx()];
        if (volume->volume_idx() >= int(object->volumes.size()))
            continue;
        // Skip volumes the plane misses.
        const BoundingBoxf3& box = volume->transformed_bounding_box();
        if (std::abs(plane.distance(box.center())) > 0.5 * box.size().dot(plane.get_normal().cwiseAbs()))
            continue;
 
        auto node = m_section_view_caps.extract(volume);
        MeshClipper& clipper = node ? caps.insert(std::move(node)).position->second : caps[volume];
        clipper.set_mesh(object->volumes[volume->volume_idx()]->mesh().its);
        clipper.set_plane(plane);
        clipper.set_transformation(Geometry::Transformation(volume->world_matrix()));
        // No cut face below the plate.
        if (m_canvas_type != CanvasAssembleView)
            clipper.set_limiting_plane(ClippingPlane(Vec3d::UnitZ(), -SINKING_Z_THRESHOLD));
        clipper.render_cut({ 0.25f, 0.25f, 0.25f, 1.0f });
    }
    m_section_view_caps = std::move(caps);
}

References _get_section_view_plane(), _render_section_view_caps(), CanvasAssembleView, Slic3r::BoundingBox3Base< PointType >::center(), Slic3r::GUI::ClippingPlane::ClipsNothing(), Slic3r::GUI::ClippingPlane::distance(), Slic3r::GUI::ClippingPlane::get_normal(), Slic3r::GUI::ClippingPlane::is_active(), m_canvas_type, m_gizmos, m_model, m_section_view_caps, m_volumes, Slic3r::GLVolume::object_idx(), Slic3r::GUI::MeshClipper::render_cut(), Slic3r::GUI::MeshClipper::set_limiting_plane(), Slic3r::GUI::MeshClipper::set_mesh(), Slic3r::GUI::MeshClipper::set_plane(), Slic3r::GUI::MeshClipper::set_transformation(), Slic3r::SINKING_Z_THRESHOLD, Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::GLVolume::transformed_bounding_box(), Slic3r::GLVolume::volume_idx(), Slic3r::ModelObject::volumes, and Slic3r::GLVolume::world_matrix().

Referenced by _render_objects(), and _render_section_view_caps().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_section_view_panel()

void Slic3r::GUI::GLCanvas3D::_render_section_view_panel ( const ImVec2 & bottom_left )

private

{
    if (!m_section_view->panel_open)
        return;
 
    ImGuiWrapper& imgui = *wxGetApp().imgui();
    const float   sc    = get_scale();
 
    ImGuiWrapper::push_toolbar_style(sc);
    ImGui::PushStyleColor(ImGuiCol_WindowBg, m_is_dark ? ImGuiWrapper::COL_TOOLBAR_BG_DARK : ImGuiWrapper::COL_TOOLBAR_BG);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.f * sc);
    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(12.f, 8.f) * sc);
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.f, 4.f) * sc);
 
    ImGui::SetNextWindowPos(bottom_left, ImGuiCond_Always, ImVec2(0.f, 1.f));
    imgui.begin(std::string("##CanvasSectionView"), ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoMove |
                                                   ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoScrollbar);
 
    const wxString alt = GUI::shortkey_alt_prefix();
    const std::vector<std::pair<wxString, wxString>> tips = {
        { alt + _L("Mouse wheel"),    _L("Move section plane") },
        { _L("Mouse wheel on icon"),  _L("Move section plane") },
        { _L("Right click on icon"),  _L("Toggle section view") },
        { _L("Middle click on icon"), _L("Set viewing angle") },
    };
    // render_tooltip_button() puts the tips below y plus the panel height; they go above the panel.
    const ImGuiStyle& style  = ImGui::GetStyle();
    const float       tips_h = tips.size() * (ImGui::GetTextLineHeight() + style.ItemSpacing.y) - style.ItemSpacing.y + 2.f * style.WindowPadding.y;
    GLGizmoUtils::render_tooltip_button(&imgui, *this, tips, ImGui::GetWindowPos().x,
        ImGui::GetWindowPos().y - style.ItemSpacing.y - tips_h - ImGui::GetContentRegionMax().y - ImGui::GetFrameHeight());
 
    ImGui::SameLine();
    ImGui::AlignTextToFramePadding();
    imgui.text(_L("Section view"));
 
    float ratio = float(get_section_view_ratio());
    ImGui::SameLine();
    ImGui::SetNextItemWidth(imgui.scaled(7.f));
    bool changed = imgui.bbl_slider_float_style("##section_view", &ratio, 0.f, 1.f, "%.2f", 1.0f, true);
    ImGui::SameLine();
    ImGui::SetNextItemWidth(1.5f * imgui.get_slider_icon_size().x);
    changed |= ImGui::BBLDragFloat("##section_view_input", &ratio, 0.05f, 0.0f, 0.0f, "%.2f");
    if (changed)
        set_section_view_ratio(ratio);
 
    ImGui::SameLine();
    if (imgui.button(_L("Set viewing angle")))
        align_section_view_to_camera();
 
    imgui.disabled_begin(!is_section_view_active());
    ImGui::SameLine();
    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.f, 0.f, 0.f, 0.f));
    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.f, 0.f, 0.f, 0.f));
    ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.f, 0.f, 0.f, 0.f));
    ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.f);
    if (imgui.button(wxString(ImGui::RevertBtn) + "##section_view_reset", _L("Reset")))
        set_section_view_ratio(0.);
    ImGui::PopStyleVar();
    ImGui::PopStyleColor(3);
    imgui.disabled_end();
 
    imgui.end();
 
    ImGui::PopStyleVar(3);
    ImGui::PopStyleColor();
    ImGuiWrapper::pop_toolbar_style();
}

Referenced by _render_section_view_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_selection()

void Slic3r::GUI::GLCanvas3D::_render_selection ( )

private

{
    float scale_factor = 1.0;
#if ENABLE_RETINA_GL
    scale_factor = m_retina_helper->get_scale_factor();
#endif // ENABLE_RETINA_GL
 
    if (!m_gizmos.is_running())
        m_selection.render(scale_factor);
}

References _render_selection(), m_gizmos, and m_selection.

Referenced by _render_scene(), and _render_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_selection_sidebar_hints()

void Slic3r::GUI::GLCanvas3D::_render_selection_sidebar_hints ( )

inlineprivate

1604{ m_selection.render_sidebar_hints(m_sidebar_field, m_gizmos.get_uniform_scaling()); }

References m_gizmos, m_selection, and m_sidebar_field.

Referenced by _render_scene().

Here is the caller graph for this function:

◆ _render_separator_toolbar_left()

void Slic3r::GUI::GLCanvas3D::_render_separator_toolbar_left ( ) const

private

{
    if (!m_separator_toolbar.is_enabled())
        return;
 
    const Size cnv_size = get_canvas_size();
    const float top = 0.5f * (float)cnv_size.get_height();
    const float main_toolbar_left = -0.5f * cnv_size.get_width() + get_main_toolbar_offset();
    const float left = main_toolbar_left + (m_main_toolbar.get_width());
 
    m_separator_toolbar.set_position(top, left);
    m_separator_toolbar.render(*this,GLToolbarItem::SeparatorLine);
}

References _render_separator_toolbar_left(), get_canvas_size(), Slic3r::GUI::Size::get_height(), get_main_toolbar_offset(), Slic3r::GUI::Size::get_width(), m_main_toolbar, m_separator_toolbar, and Slic3r::GUI::GLToolbarItem::SeparatorLine.

Referenced by _render_overlay_toolbars(), and _render_separator_toolbar_left().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_separator_toolbar_right()

void Slic3r::GUI::GLCanvas3D::_render_separator_toolbar_right ( ) const

private

{
    if (!m_separator_toolbar.is_enabled())
        return;
 
    const Size cnv_size = get_canvas_size();
    const float gizmo_width = m_gizmos.get_scaled_total_width();
    const float separator_width = m_separator_toolbar.get_width();
    const float top = 0.5f * (float)cnv_size.get_height();
    const float main_toolbar_left = -0.5f * cnv_size.get_width() + get_main_toolbar_offset();
    const float left = main_toolbar_left + (m_main_toolbar.get_width() + gizmo_width + separator_width / 2);
 
    m_separator_toolbar.set_position(top, left);
    m_separator_toolbar.render(*this,GLToolbarItem::SeparatorLine);
}

References _render_separator_toolbar_right(), get_canvas_size(), Slic3r::GUI::Size::get_height(), get_main_toolbar_offset(), Slic3r::GUI::Size::get_width(), m_gizmos, m_main_toolbar, m_separator_toolbar, and Slic3r::GUI::GLToolbarItem::SeparatorLine.

Referenced by _render_overlay_toolbars(), and _render_separator_toolbar_right().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_sequential_clearance()

void Slic3r::GUI::GLCanvas3D::_render_sequential_clearance ( )

private

{
    if (m_gizmos.is_dragging())
        return;
    auto type = m_gizmos.get_current_type();
    if (type == GLGizmosManager::EType::Undefined
        || can_sequential_clearance_show_in_gizmo()) {
        m_sequential_print_clearance.render();
    }
}

References _render_sequential_clearance(), can_sequential_clearance_show_in_gizmo(), m_gizmos, m_sequential_print_clearance, and Slic3r::GUI::GLGizmosManager::Undefined.

Referenced by _render_scene(), and _render_sequential_clearance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_shadows()

void Slic3r::GUI::GLCanvas3D::_render_shadows	(	const Transform3d &	view_matrix,
		const Transform3d &	projection_matrix )

private

{
    if (wxGetApp().app_config == nullptr)
        return;
    if (!_is_realistic_view_enabled())
        return;
    const EShadowMode mode = _shadow_mode();
    if (mode == EShadowMode::Off)
        return;
 
    // The preview canvas holds no volumes of its own for FFF. Once slicing has run its printed
    // geometry is the G-code toolpaths, which both cast into the map here and sample it back in
    // _render_gcode; before slicing there are only shells, and nothing casts at all. View3D and
    // SLA preview use m_volumes. The shells are deliberately never casters: they are a
    // translucent ghost of the whole object, so they would drop the solid shadow of a print that
    // has not been sliced, and at any layer below the last, one that is not there yet.
    const bool toolpath_casters = m_canvas_type == ECanvasType::CanvasPreview && m_gcode_viewer.has_data();
    if (!toolpath_casters && m_volumes.empty())
        return;
 
    if (OpenGLManager::get_framebuffers_type() == OpenGLManager::EFramebufferType::Arb) {
 
        // Orbit: the light used for shading, fixed to the camera. Static: a world light, also used for shading.
        const Vec3d light_dir_eye = Vec3d(-0.4574957, 0.4574957, 0.7624929).normalized();
        const Matrix3d view_rot = view_matrix.matrix().block<3, 3>(0, 0);
        const Vec3d dir_to_light = mode == EShadowMode::Static ? STATIC_LIGHT_DIR :
                                                                 Vec3d((view_rot.transpose() * light_dir_eye).normalized());
 
        // Bounding box of the printable objects (the shadow casters).
        BoundingBoxf3 obj_bb;
        if (toolpath_casters) {
            // Merged corner by corner: BoundingBoxf3(min, max) marks itself undefined at zero
            // Z extent, which a single layer print gives, and the check below would then drop
            // every shadow in the frame.
            const BoundingBoxf3& paths_bb = m_gcode_viewer.get_paths_bounding_box();
            if ((paths_bb.min.array() <= paths_bb.max.array()).all()) {
                obj_bb.merge(paths_bb.min);
                obj_bb.merge(paths_bb.max);
            }
            // Only the enabled layers are drawn, so fitting the map to the whole print wastes
            // its depth range and makes contact shadows shift as the slider moves. The z = 0
            // shadow is enclosed separately below, so the plate shadow is unaffected.
            const std::vector<double> layer_zs = m_gcode_viewer.get_layers_zs();
            if (!layer_zs.empty()) {
                const size_t top = std::min<size_t>(m_gcode_viewer.get_layers_z_range()[1], layer_zs.size() - 1);
                obj_bb.max.z() = std::max(obj_bb.min.z(), std::min(obj_bb.max.z(), layer_zs[top]));
            }
        }
        else {
            for (const GLVolume* volume : m_volumes.volumes) {
                if (volume == nullptr || !volume->is_active || !volume->printable || volume->is_modifier || volume->is_wipe_tower)
                    continue;
                obj_bb.merge(volume->transformed_bounding_box());
            }
        }
        if (!obj_bb.defined)
            return; // no objects to cast shadows
 
        // Orthographic light-space basis (z points toward the light).
        const Vec3d up     = (std::abs(dir_to_light.z()) > 0.99) ? Vec3d::UnitY() : Vec3d::UnitZ();
        const Vec3d z_axis = dir_to_light;
        const Vec3d x_axis = up.cross(z_axis).normalized();
        const Vec3d y_axis = z_axis.cross(x_axis).normalized();
 
        // Fit the frustum to the object AABB *and* the object's shadow projected onto the plate
        // (clamped to the plate footprint). This keeps the map tight/high-res for short shadows
        // while still covering long shadows at grazing light angles, which previously fell outside
        // the map and were clipped.
        const Vec3d ray_dir = -dir_to_light; // direction the shadow travels
        const BoundingBoxf3 plate_bb = m_bed.build_volume().valid() ? m_bed.build_volume().bounding_volume() : obj_bb;
 
        Vec3d lmin(DBL_MAX, DBL_MAX, DBL_MAX);
        Vec3d lmax(-DBL_MAX, -DBL_MAX, -DBL_MAX);
        auto enclose = [&](const Vec3d& p) {
            const Vec3d lp(x_axis.dot(p), y_axis.dot(p), z_axis.dot(p));
            lmin = lmin.cwiseMin(lp);
            lmax = lmax.cwiseMax(lp);
        };
        // The plate area a shadow can reach: the casters' footprint and where their corners land on z = 0.
        Vec2d reach_min(DBL_MAX, DBL_MAX);
        Vec2d reach_max(-DBL_MAX, -DBL_MAX);
        auto reach = [&](const Vec3d& p) {
            reach_min = reach_min.cwiseMin(Vec2d(p.x(), p.y()));
            reach_max = reach_max.cwiseMax(Vec2d(p.x(), p.y()));
        };
        for (int i = 0; i < 8; ++i) {
            const Vec3d corner((i & 1) ? obj_bb.max.x() : obj_bb.min.x(),
                               (i & 2) ? obj_bb.max.y() : obj_bb.min.y(),
                               (i & 4) ? obj_bb.max.z() : obj_bb.min.z());
            enclose(corner);
            reach(corner);
            // Where this corner's shadow lands on z = 0, clamped to the plate so a grazing angle
            // (t -> infinity) stays bounded.
            if (ray_dir.z() < -1e-6) {
                const double t = -corner.z() / ray_dir.z();
                Vec3d s = corner + t * ray_dir;
                s.x() = std::min(std::max(s.x(), plate_bb.min.x()), plate_bb.max.x());
                s.y() = std::min(std::max(s.y(), plate_bb.min.y()), plate_bb.max.y());
                s.z() = 0.0;
                enclose(s);
                reach(s);
            }
        }
 
        // Light "camera" placed just past the nearest enclosed point, looking toward the scene.
        const double range  = lmax.z() - lmin.z();
        const double margin = std::max(1.0, 0.05 * range);
        const double cx     = 0.5 * (lmin.x() + lmax.x());
        const double cy     = 0.5 * (lmin.y() + lmax.y());
        const Vec3d  eye     = x_axis * cx + y_axis * cy + z_axis * (lmax.z() + margin);
 
        Matrix4d light_view = Matrix4d::Identity();
        light_view.block<1, 3>(0, 0) = x_axis.transpose();
        light_view.block<1, 3>(1, 0) = y_axis.transpose();
        light_view.block<1, 3>(2, 0) = z_axis.transpose();
        light_view(0, 3) = -x_axis.dot(eye);
        light_view(1, 3) = -y_axis.dot(eye);
        light_view(2, 3) = -z_axis.dot(eye);
 
        // Ortho fit to the light-space extent (symmetric in X/Y around cx,cy; +2% edge padding).
        const double halfx  = std::max(0.5 * (lmax.x() - lmin.x()), 1.0) * 1.02;
        const double halfy  = std::max(0.5 * (lmax.y() - lmin.y()), 1.0) * 1.02;
        const double near_z = margin * 0.5;
        const double far_z  = range + margin * 1.5;
        Matrix4d light_proj = Matrix4d::Identity();
        light_proj(0, 0) = 1.0 / halfx;
        light_proj(1, 1) = 1.0 / halfy;
        light_proj(2, 2) = -2.0 / (far_z - near_z);
        light_proj(2, 3) = -(far_z + near_z) / (far_z - near_z);
 
        m_shadow_light_vp = Transform3d(light_proj * light_view);
 
        // Create / resize the depth texture and FBO
        const unsigned int size = 2048;
 
        // Padded by the filter's 2 texel reach, stretched where the light grazes the plate.
        const double reach_margin = 3.0 * 2.0 * std::max(halfx, halfy) / size / std::max(0.1, std::abs(dir_to_light.z()));
        m_shadow_plate_bounds = { float(reach_min.x() - reach_margin), float(reach_min.y() - reach_margin),
                                  float(reach_max.x() + reach_margin), float(reach_max.y() + reach_margin) };
        if (m_shadow_map_texture_id == 0) {
            glsafe(::glGenTextures(1, &m_shadow_map_texture_id));
            glsafe(::glBindTexture(GL_TEXTURE_2D, m_shadow_map_texture_id));
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER));
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER));
            const float border[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
            glsafe(::glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border));
            m_shadow_map_size = 0;
        }
        if (m_shadow_map_size != size) {
            glsafe(::glBindTexture(GL_TEXTURE_2D, m_shadow_map_texture_id));
            glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, size, size, 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr));
            m_shadow_map_size = size;
        }
        if (m_shadow_map_fbo == 0)
            glsafe(::glGenFramebuffers(1, &m_shadow_map_fbo));
 
        // A static light keeps the map until its frustum or the casters change.
        size_t cache_key = 0;
        if (mode == EShadowMode::Static) {
            cache_key = _shadow_casters_signature(toolpath_casters);
            for (int i = 0; i < 16; ++i)
                boost::hash_combine(cache_key, m_shadow_light_vp.matrix().data()[i]);
        }
        if (cache_key != 0 && cache_key == m_shadow_map_key)
            m_shadow_map_valid = true;
        else {
            m_shadow_map_key = 0;
            // Save OpenGL state that we will modify
            GLint prev_viewport[4] = { 0, 0, 0, 0 };
            glsafe(::glGetIntegerv(GL_VIEWPORT, prev_viewport));
            GLint prev_fbo = 0;
            glsafe(::glGetIntegerv(GL_FRAMEBUFFER_BINDING, &prev_fbo));
            GLboolean prev_color_mask[4] = { GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE };
            glsafe(::glGetBooleanv(GL_COLOR_WRITEMASK, prev_color_mask));
            const GLboolean prev_cull = ::glIsEnabled(GL_CULL_FACE);
            GLint prev_depth_func = GL_LESS;
            glsafe(::glGetIntegerv(GL_DEPTH_FUNC, &prev_depth_func));
            GLboolean prev_depth_mask = GL_TRUE;
            glsafe(::glGetBooleanv(GL_DEPTH_WRITEMASK, &prev_depth_mask));
            glsafe(::glBindFramebuffer(GL_FRAMEBUFFER, m_shadow_map_fbo));
            glsafe(::glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_shadow_map_texture_id, 0));
            glsafe(::glDrawBuffer(GL_NONE));
            glsafe(::glReadBuffer(GL_NONE));
 
            if (::glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
                glsafe(::glBindFramebuffer(GL_FRAMEBUFFER, static_cast<GLuint>(prev_fbo)));
                m_shadow_map_valid = false;
            } else {
                glsafe(::glViewport(0, 0, size, size));
                glsafe(::glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE));
                glsafe(::glEnable(GL_DEPTH_TEST));
                glsafe(::glDepthMask(GL_TRUE));
                glsafe(::glDepthFunc(GL_LESS));
                glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
                glsafe(::glEnable(GL_POLYGON_OFFSET_FILL));
                glsafe(::glPolygonOffset(4.0f, 4.0f));
                glsafe(::glDisable(GL_CULL_FACE));
 
                if (toolpath_casters)
                    m_gcode_viewer.render_shadow_casters(Transform3d(light_view), Transform3d(light_proj), eye);
                // Only this branch draws through "flat"; the toolpaths bring their own program.
                else if (GLShaderProgram* shader = wxGetApp().get_shader("flat"); shader != nullptr) {
                    shader->start_using();
                    shader->set_uniform("projection_matrix", Transform3d(light_proj));
                    for (GLVolume* volume : m_volumes.volumes) {
                        if (volume == nullptr || !volume->is_active || !volume->printable || volume->is_modifier || volume->is_wipe_tower)
                            continue;
                        const Transform3d view_model = Transform3d(light_view) * volume->world_matrix();
                        shader->set_uniform("view_model_matrix", view_model);
                        volume->model.render(shader);
                    }
                    shader->stop_using();
                }
 
                // Restore state
                glsafe(::glDisable(GL_POLYGON_OFFSET_FILL));
                glsafe(::glColorMask(prev_color_mask[0], prev_color_mask[1], prev_color_mask[2], prev_color_mask[3]));
                if (prev_cull)
                    glsafe(::glEnable(GL_CULL_FACE));
                else
                    glsafe(::glDisable(GL_CULL_FACE));
                glsafe(::glDepthFunc(prev_depth_func));
                glsafe(::glDepthMask(prev_depth_mask));
                glsafe(::glBindFramebuffer(GL_FRAMEBUFFER, static_cast<GLuint>(prev_fbo)));
                glsafe(::glViewport(prev_viewport[0], prev_viewport[1], prev_viewport[2], prev_viewport[3]));
 
                m_shadow_map_valid = true;
            }
            if (m_shadow_map_valid)
                m_shadow_map_key = cache_key;
        }
    } else {
        m_shadow_map_valid = false;
    }
 
    // ----------------------------------------------------------------------------------
    // Unified plate shadow: draw the build-plate footprint and darken it wherever the same
    // depth shadow map (built above) says the light is occluded. This replaces the old planar
    // stencil projection so plate, object and self shadows all come from one technique.
    // ----------------------------------------------------------------------------------
    if (!m_shadow_map_valid)
        return;
 
    GLShaderProgram* plate_shader = wxGetApp().get_shader("printbed_shadow");
    if (plate_shader == nullptr)
        return;
 
    if (const BuildVolume& build_volume = m_bed.build_volume(); build_volume.valid()) {
        const std::string mask_key = build_volume.type() == BuildVolume_Type::Rectangle
            ? (boost::format("rect|%1$.5f|%2$.5f|%3$.5f|%4$.5f")
                % build_volume.bounding_volume().min.x()
                % build_volume.bounding_volume().min.y()
                % build_volume.bounding_volume().max.x()
                % build_volume.bounding_volume().max.y()).str()
            : (build_volume.type() == BuildVolume_Type::Circle
                ? (boost::format("circle|%1$.5f|%2$.5f|%3$.5f")
                    % unscaled<double>(build_volume.circle().center.x())
                    % unscaled<double>(build_volume.circle().center.y())
                    % unscaled<double>(build_volume.circle().radius)).str()
                : std::string("invalid"));
 
        if (mask_key != m_plate_shadow_mask_key) {
            m_plate_shadow_mask.reset();
            m_plate_shadow_mask_key = mask_key;
 
            GLModel::Geometry mask;
            mask.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3 };
 
            if (build_volume.type() == BuildVolume_Type::Rectangle) {
                const BoundingBox3Base<Vec3d> bb = build_volume.bounding_volume();
                mask.reserve_vertices(4);
                mask.reserve_indices(6);
                mask.add_vertex(Vec3f((float)bb.min.x(), (float)bb.min.y(), 0.0f));
                mask.add_vertex(Vec3f((float)bb.max.x(), (float)bb.min.y(), 0.0f));
                mask.add_vertex(Vec3f((float)bb.max.x(), (float)bb.max.y(), 0.0f));
                mask.add_vertex(Vec3f((float)bb.min.x(), (float)bb.max.y(), 0.0f));
                mask.add_triangle(0, 1, 2);
                mask.add_triangle(0, 2, 3);
            }
            else if (build_volume.type() == BuildVolume_Type::Circle) {
                const Vec2f c = Vec2f(unscaled<float>(build_volume.circle().center.x()), unscaled<float>(build_volume.circle().center.y()));
                const float r = unscaled<float>(build_volume.circle().radius);
                const int segments = 64;
                mask.reserve_vertices(segments + 1);
                mask.reserve_indices(segments * 3);
                mask.add_vertex(Vec3f(c.x(), c.y(), 0.0f));
                for (int i = 0; i < segments; ++i) {
                    const float a = (2.0f * float(PI) * float(i)) / float(segments);
                    mask.add_vertex(Vec3f(c.x() + r * std::cos(a), c.y() + r * std::sin(a), 0.0f));
                }
                for (int i = 0; i < segments; ++i) {
                    const unsigned int i1 = 1 + i;
                    const unsigned int i2 = 1 + ((i + 1) % segments);
                    mask.add_triangle(0, i1, i2);
                }
            }
 
            if (mask.vertices_count() > 0 && mask.indices_count() > 0)
                m_plate_shadow_mask.init_from(std::move(mask));
        }
 
        if (m_plate_shadow_mask.is_initialized()) {
            // Blend the shadow over the already-drawn plate. Depth test keeps it behind anything
            // already in front; depth writes are off, and a small negative polygon offset lifts it
            // just above the bed to avoid z-fighting.
            GLboolean prev_depth_mask = GL_TRUE;
            glsafe(::glGetBooleanv(GL_DEPTH_WRITEMASK, &prev_depth_mask));
            GLint prev_depth_func = GL_LESS;
            glsafe(::glGetIntegerv(GL_DEPTH_FUNC, &prev_depth_func));
 
            glsafe(::glEnable(GL_DEPTH_TEST));
            glsafe(::glDepthMask(GL_FALSE));
            glsafe(::glDepthFunc(GL_LEQUAL));
            glsafe(::glEnable(GL_BLEND));
            glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
            glsafe(::glEnable(GL_POLYGON_OFFSET_FILL));
            glsafe(::glPolygonOffset(-1.0f, -1.0f));
 
            glsafe(::glActiveTexture(GL_TEXTURE4));
            glsafe(::glBindTexture(GL_TEXTURE_2D, m_shadow_map_texture_id));
            glsafe(::glActiveTexture(GL_TEXTURE0));
 
            plate_shader->start_using();
            plate_shader->set_uniform("view_model_matrix", view_matrix);
            plate_shader->set_uniform("projection_matrix", projection_matrix);
            plate_shader->set_uniform("shadow_map", 4);
            plate_shader->set_uniform("shadow_light_vp", m_shadow_light_vp);
            plate_shader->set_uniform("shadow_intensity", 0.35f);
            plate_shader->set_uniform("shadow_map_texel", 1.0f / static_cast<float>(m_shadow_map_size));
            plate_shader->set_uniform("shadow_bounds", m_shadow_plate_bounds);
            m_plate_shadow_mask.render(plate_shader);
            plate_shader->stop_using();
 
            glsafe(::glActiveTexture(GL_TEXTURE4));
            glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
            glsafe(::glActiveTexture(GL_TEXTURE0));
 
            glsafe(::glDisable(GL_POLYGON_OFFSET_FILL));
            glsafe(::glDisable(GL_BLEND));
            glsafe(::glDepthFunc(prev_depth_func));
            glsafe(::glDepthMask(prev_depth_mask));
        }
    }
}

Referenced by _render_scene(), and _render_shadows().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_sla_slices()

void Slic3r::GUI::GLCanvas3D::_render_sla_slices ( )

private

{
    if (!m_use_clipping_planes || current_printer_technology() != ptSLA)
        return;
 
    const SLAPrint* print = this->sla_print();
    const PrintObjects& print_objects = print->objects();
    if (print_objects.empty())
        // nothing to render, return
        return;
 
    double clip_min_z = -m_clipping_planes[0].get_data()[3];
    double clip_max_z = m_clipping_planes[1].get_data()[3];
    for (unsigned int i = 0; i < (unsigned int)print_objects.size(); ++i) {
        const SLAPrintObject* obj = print_objects[i];
 
        if (!obj->is_step_done(slaposSliceSupports))
            continue;
 
        SlaCap::ObjectIdToModelsMap::iterator it_caps_bottom = m_sla_caps[0].triangles.find(i);
        SlaCap::ObjectIdToModelsMap::iterator it_caps_top = m_sla_caps[1].triangles.find(i);
        {
            if (it_caps_bottom == m_sla_caps[0].triangles.end())
                it_caps_bottom = m_sla_caps[0].triangles.emplace(i, SlaCap::Triangles()).first;
            if (!m_sla_caps[0].matches(clip_min_z)) {
                m_sla_caps[0].z = clip_min_z;
                it_caps_bottom->second.object.reset();
                it_caps_bottom->second.supports.reset();
            }
            if (it_caps_top == m_sla_caps[1].triangles.end())
                it_caps_top = m_sla_caps[1].triangles.emplace(i, SlaCap::Triangles()).first;
            if (!m_sla_caps[1].matches(clip_max_z)) {
                m_sla_caps[1].z = clip_max_z;
                it_caps_top->second.object.reset();
                it_caps_top->second.supports.reset();
            }
        }
        GLModel& bottom_obj_triangles = it_caps_bottom->second.object;
        GLModel& bottom_sup_triangles = it_caps_bottom->second.supports;
        GLModel& top_obj_triangles = it_caps_top->second.object;
        GLModel& top_sup_triangles = it_caps_top->second.supports;
 
        auto init_model = [](GLModel& model, const Pointf3s& triangles, const ColorRGBA& color) {
            GLModel::Geometry init_data;
            init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3 };
            init_data.reserve_vertices(triangles.size());
            init_data.reserve_indices(triangles.size() / 3);
            init_data.color = color;
 
            unsigned int vertices_count = 0;
            for (const Vec3d& v : triangles) {
                init_data.add_vertex((Vec3f)v.cast<float>());
                ++vertices_count;
                if (vertices_count % 3 == 0) {
                    init_data.add_triangle(vertices_count - 3, vertices_count - 2, vertices_count - 1);
                }
            }
 
            if (!init_data.is_empty())
                model.init_from(std::move(init_data));
        };
 
        if ((!bottom_obj_triangles.is_initialized() || !bottom_sup_triangles.is_initialized() ||
            !top_obj_triangles.is_initialized() || !top_sup_triangles.is_initialized()) && !obj->get_slice_index().empty()) {
            double layer_height         = print->default_object_config().layer_height.value;
            double initial_layer_height = print->material_config().initial_layer_height.value;
            bool   left_handed          = obj->is_left_handed();
 
            coord_t key_zero = obj->get_slice_index().front().print_level();
            // Slice at the center of the slab starting at clip_min_z will be rendered for the lower plane.
            coord_t key_low  = coord_t((clip_min_z - initial_layer_height + layer_height) / SCALING_FACTOR) + key_zero;
            // Slice at the center of the slab ending at clip_max_z will be rendered for the upper plane.
            coord_t key_high = coord_t((clip_max_z - initial_layer_height) / SCALING_FACTOR) + key_zero;
 
            const SliceRecord& slice_low  = obj->closest_slice_to_print_level(key_low, coord_t(SCALED_EPSILON));
            const SliceRecord& slice_high = obj->closest_slice_to_print_level(key_high, coord_t(SCALED_EPSILON));
 
            // Offset to avoid OpenGL Z fighting between the object's horizontal surfaces and the triangluated surfaces of the cuts.
            double plane_shift_z = 0.002;
 
            if (slice_low.is_valid()) {
                const ExPolygons& obj_bottom = slice_low.get_slice(soModel);
                const ExPolygons& sup_bottom = slice_low.get_slice(soSupport);
                // calculate model bottom cap
                // calculate model bottom cap
                if (!bottom_obj_triangles.is_initialized() && !obj_bottom.empty())
                    init_model(bottom_obj_triangles, triangulate_expolygons_3d(obj_bottom, clip_min_z - plane_shift_z, !left_handed), { 1.0f, 0.37f, 0.0f, 1.0f });
                // calculate support bottom cap
                if (!bottom_sup_triangles.is_initialized() && !sup_bottom.empty())
                    init_model(bottom_sup_triangles, triangulate_expolygons_3d(sup_bottom, clip_min_z - plane_shift_z, !left_handed), { 1.0f, 0.0f, 0.37f, 1.0f });
            }
 
            if (slice_high.is_valid()) {
                const ExPolygons& obj_top = slice_high.get_slice(soModel);
                const ExPolygons& sup_top = slice_high.get_slice(soSupport);
                // calculate model top cap
                // calculate model top cap
                if (!top_obj_triangles.is_initialized() && !obj_top.empty())
                    init_model(top_obj_triangles, triangulate_expolygons_3d(obj_top, clip_max_z + plane_shift_z, left_handed), { 1.0f, 0.37f, 0.0f, 1.0f });
                // calculate support top cap
                if (!top_sup_triangles.is_initialized() && !sup_top.empty())
                    init_model(top_sup_triangles, triangulate_expolygons_3d(sup_top, clip_max_z + plane_shift_z, left_handed), { 1.0f, 0.0f, 0.37f, 1.0f });
            }
        }
 
        GLShaderProgram* shader = wxGetApp().get_shader("flat");
        if (shader != nullptr) {
            shader->start_using();
 
            for (const SLAPrintObject::Instance& inst : obj->instances()) {
                const Camera& camera = wxGetApp().plater()->get_camera();
                const Transform3d view_model_matrix = camera.get_view_matrix() *
                    Geometry::assemble_transform(Vec3d(unscale<double>(inst.shift.x()), unscale<double>(inst.shift.y()), 0.0),
                        inst.rotation * Vec3d::UnitZ(), Vec3d::Ones(),
                        obj->is_left_handed() ? Vec3d(-1.0f, 1.0f, 1.0f) : Vec3d::Ones());
 
                shader->set_uniform("view_model_matrix", view_model_matrix);
                shader->set_uniform("projection_matrix", camera.get_projection_matrix());
 
                bottom_obj_triangles.render();
                top_obj_triangles.render();
                bottom_sup_triangles.render();
                top_sup_triangles.render();
 
            }
 
            shader->stop_using();
        }
    }
}

Referenced by _render_scene(), and _render_sla_slices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_ssao_pass()

void Slic3r::GUI::GLCanvas3D::_render_ssao_pass	(	unsigned int	width,
		unsigned int	height )

private

{
    if (width == 0 || height == 0)
        return;
 
    GLShaderProgram* shader = wxGetApp().get_shader("ssao");
    if (shader == nullptr)
        return;
 
    if (m_ssao_color_texture_id == 0) {
        glsafe(::glGenTextures(1, &m_ssao_color_texture_id));
         glsafe(::glBindTexture(GL_TEXTURE_2D, m_ssao_color_texture_id));
         glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
         glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
         glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
         glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
     }
     if (m_ssao_depth_texture_id == 0) {
         glsafe(::glGenTextures(1, &m_ssao_depth_texture_id));
         glsafe(::glBindTexture(GL_TEXTURE_2D, m_ssao_depth_texture_id));
         glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
         glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
         glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
         glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
     }
 
    if (m_ssao_texture_size[0] != width || m_ssao_texture_size[1] != height) {
        glsafe(::glBindTexture(GL_TEXTURE_2D, m_ssao_color_texture_id));
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr));
        glsafe(::glBindTexture(GL_TEXTURE_2D, m_ssao_depth_texture_id));
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, nullptr));
        m_ssao_texture_size = { { width, height } };
    }
 
    glsafe(::glBindTexture(GL_TEXTURE_2D, m_ssao_color_texture_id));
    glsafe(::glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width, height));
    glsafe(::glBindTexture(GL_TEXTURE_2D, m_ssao_depth_texture_id));
    glsafe(::glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width, height));
 
    const Camera& camera = wxGetApp().plater()->get_camera();
 
    glsafe(::glDisable(GL_DEPTH_TEST));
    glsafe(::glDisable(GL_BLEND));
 
    shader->start_using();
    shader->set_uniform("view_model_matrix", Transform3d::Identity());
    shader->set_uniform("projection_matrix", Transform3d::Identity());
    shader->set_uniform("color_texture", 0);
    shader->set_uniform("depth_texture", 1);
    shader->set_uniform("inv_tex_size", Vec2f(1.0f / static_cast<float>(width), 1.0f / static_cast<float>(height)));
    shader->set_uniform("z_far", camera.get_far_z());
    // The shader reconstructs the surface normal from the depth buffer, there being no normal
    // target to read: it unprojects a pixel back into view space, then measures the result
    // against world +Z expressed in view space to tell a top surface from a wall.
    const Matrix4d inv_projection_matrix = camera.get_projection_matrix().matrix().inverse();
    shader->set_uniform("inv_projection_matrix", inv_projection_matrix);
    const Vec3d up_view = (camera.get_view_matrix().matrix().block<3, 3>(0, 0) * Vec3d::UnitZ()).normalized();
    shader->set_uniform("up_view", up_view);
 
    glsafe(::glActiveTexture(GL_TEXTURE0));
    glsafe(::glBindTexture(GL_TEXTURE_2D, m_ssao_color_texture_id));
    glsafe(::glActiveTexture(GL_TEXTURE1));
    glsafe(::glBindTexture(GL_TEXTURE_2D, m_ssao_depth_texture_id));
    m_background.render();
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
    glsafe(::glActiveTexture(GL_TEXTURE0));
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
    shader->stop_using();
 
    glsafe(::glEnable(GL_DEPTH_TEST));
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
}

References _render_ssao_pass(), camera, GL_BLEND, GL_CLAMP_TO_EDGE, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT24, GL_DEPTH_TEST, GL_LINEAR, GL_NEAREST, GL_ONE_MINUS_SRC_ALPHA, GL_RGBA, GL_SRC_ALPHA, GL_TEXTURE0, GL_TEXTURE1, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_UNSIGNED_BYTE, GL_UNSIGNED_INT, glActiveTexture, glBindTexture, glBlendFunc, glCopyTexSubImage2D, glDisable, glEnable, glGenTextures, glsafe, glTexImage2D, glTexParameteri, m_background, m_ssao_color_texture_id, m_ssao_depth_texture_id, m_ssao_texture_size, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Referenced by _render_scene(), and _render_ssao_pass().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_style_editor()

void Slic3r::GUI::GLCanvas3D::_render_style_editor ( )

private

{
    bool show_style_editor = true;
    ImGui::Begin("ImGui Style Editor", &show_style_editor);
    // You can pass in a reference ImGuiStyle structure to compare to, revert to and save to
    // (without a reference style pointer, we will use one compared locally as a reference)
 
    ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.50f);
    ImGui::ShowFontSelector("Fonts##Selector");
    ImGui::Separator();
 
    if (ImGui::BeginTabBar("##tabs", ImGuiTabBarFlags_None))
    {
        if (ImGui::BeginTabItem("Colors"))
        {
            static int output_dest = 0;
            static bool output_only_modified = false;
            if (ImGui::Button("Export"))
            {
                if (output_dest == 0)
                    ImGui::LogToClipboard();
                else
                    ImGui::LogToTTY();
 
                ImGui::LogText("RenderColors:" IM_NEWLINE);
                for (int i = 0; i < RenderCol_Count; i++)
                {
                    const ImVec4& col = RenderColor::colors[i];
                    const char* name = GetRenderColName(i);
                    if (!output_only_modified || memcmp(&col, &RenderColor::colors[i], sizeof(ImVec4)) != 0)
                        ImGui::LogText("RenderColor::colors[%s]%*s= ImVec4(%.2ff, %.2ff, %.2ff, %.2ff);" IM_NEWLINE,
                            name, 23 - (int)strlen(name), "", col.x, col.y, col.z, col.w);
                }
                ImGui::LogFinish();
            }
            ImGui::SameLine(); ImGui::SetNextItemWidth(120); ImGui::Combo("##output_type", &output_dest, "To Clipboard\0To TTY\0");
            ImGui::SameLine(); ImGui::Checkbox("Only Modified Colors", &output_only_modified);
 
            static ImGuiTextFilter filter;
            filter.Draw("Filter colors", ImGui::GetFontSize() * 16);
 
            static ImGuiColorEditFlags alpha_flags = 0;
            if (ImGui::RadioButton("Opaque", alpha_flags == ImGuiColorEditFlags_None)) { alpha_flags = ImGuiColorEditFlags_None; } ImGui::SameLine();
            if (ImGui::RadioButton("Alpha", alpha_flags == ImGuiColorEditFlags_AlphaPreview)) { alpha_flags = ImGuiColorEditFlags_AlphaPreview; } ImGui::SameLine();
            if (ImGui::RadioButton("Both", alpha_flags == ImGuiColorEditFlags_AlphaPreviewHalf)) { alpha_flags = ImGuiColorEditFlags_AlphaPreviewHalf; } ImGui::SameLine();
            ImGui::TextDisabled("(?)");
            if (ImGui::IsItemHovered())
            {
                ImGui::BeginTooltip();
                ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
                ImGui::TextUnformatted("In the color list:\n"
                "Left-click on color square to open color picker,\n"
                    "Right-click to open edit options menu.");
                ImGui::PopTextWrapPos();
                ImGui::EndTooltip();
            }
            ImGui::BeginChild("##colors", ImVec2(0, 0), true, ImGuiWindowFlags_AlwaysVerticalScrollbar | ImGuiWindowFlags_AlwaysHorizontalScrollbar | ImGuiWindowFlags_NavFlattened);
            ImGui::PushItemWidth(-160);
            for (int i = 0; i < RenderCol_Count; i++)
            {
                const char* name = GetRenderColName(i);
                if (!filter.PassFilter(name))
                    continue;
                ImGui::PushID(i);
                ImGui::ColorEdit4("##color", (float*)&RenderColor::colors[i], ImGuiColorEditFlags_AlphaBar | alpha_flags);
                // Tips: in a real user application, you may want to merge and use an icon font into the main font,
                // so instead of "Save"/"Revert" you'd use icons!
                // Read the FAQ and docs/FONTS.md about using icon fonts. It's really easy and super convenient!
                ImGui::SameLine(0.0f, 3.0f);
                if (ImGui::Button("Set")) {
                    GLVolume::update_render_colors();
                    PartPlate::update_render_colors();
                    GLGizmoBase::update_render_colors();
                    GLCanvas3D::update_render_colors();
                    Bed3D::update_render_colors();
                }
                ImGui::SameLine(0.0f, 3.0f);
                ImGui::TextUnformatted(name);
                ImGui::PopID();
            }
            ImGui::PopItemWidth();
            ImGui::EndChild();
 
            ImGui::EndTabItem();
        }
 
        ImGui::EndTabBar();
    }
 
    ImGui::PopItemWidth();
    ImGui::End();
}

References _render_style_editor(), Slic3r::RenderColor::colors, Slic3r::GetRenderColName(), RenderCol_Count, Slic3r::GLVolume::update_render_colors(), Slic3r::GUI::Bed3D::update_render_colors(), update_render_colors(), Slic3r::GUI::GLGizmoBase::update_render_colors(), and Slic3r::GUI::PartPlate::update_render_colors().

Referenced by _render_frame(), and _render_style_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_volumes_for_picking()

void Slic3r::GUI::GLCanvas3D::_render_volumes_for_picking ( const Camera & camera ) const

private

{
    GLShaderProgram* shader = wxGetApp().get_shader("flat_clip");
    if (shader == nullptr)
        return;
 
    // do not cull backfaces to show broken geometry, if any
    glsafe(::glDisable(GL_CULL_FACE));
 
    const Transform3d& view_matrix = camera.get_view_matrix();
    for (size_t type = 0; type < 2; ++ type) {
        GLVolumeWithIdAndZList to_render = volumes_to_render(m_volumes.volumes, (type == 0) ? GLVolumeCollection::ERenderType::Opaque : GLVolumeCollection::ERenderType::Transparent, view_matrix);
        for (const GLVolumeWithIdAndZ& volume : to_render)
          if (!volume.first->disabled && (volume.first->composite_id.volume_id >= 0 || m_render_sla_auxiliaries)) {
            // Object picking mode. Render the object with a color encoding the object index.
                // we reserve color = (0,0,0) for occluders (as the printbed)
                // so we shift volumes' id by 1 to get the proper color
                //BBS: remove the bed picking logic
                const unsigned int id = volume.second.first;
                //const unsigned int id = 1 + volume.second.first;
                volume.first->model.set_color(picking_decode(id));
                shader->start_using();
                shader->set_uniform("view_model_matrix", view_matrix * volume.first->world_matrix());
                shader->set_uniform("projection_matrix", camera.get_projection_matrix());
                shader->set_uniform("volume_world_matrix", volume.first->world_matrix());
                shader->set_uniform("z_range", m_volumes.get_z_range());
                shader->set_uniform("clipping_plane", m_volumes.get_clipping_plane());
                volume.first->picking = true;
                volume.first->render();
                volume.first->picking = false;
                shader->stop_using();
          }
  }
 
    glsafe(::glEnable(GL_CULL_FACE));
}

References _render_volumes_for_picking(), camera, GL_CULL_FACE, glDisable, glEnable, glsafe, m_render_sla_auxiliaries, m_volumes, Slic3r::GLVolumeCollection::Opaque, Slic3r::picking_decode(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), Slic3r::GLVolumeCollection::Transparent, and Slic3r::volumes_to_render().

Referenced by _rectangular_selection_picking_pass(), and _render_volumes_for_picking().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_wireframe_overlay()

void Slic3r::GUI::GLCanvas3D::_render_wireframe_overlay ( )

private

{
    if (!wxGetApp().plater()->is_show_wireframe())
        return;
    if (m_volumes.empty())
        return;
 
#if SLIC3R_OPENGL_ES
    GLShaderProgram* shader = wxGetApp().get_shader("wireframe");
#else
    GLShaderProgram* shader = wxGetApp().get_shader("mm_contour");
#endif
    if (shader == nullptr)
        return;
 
    const Camera&      camera      = wxGetApp().plater()->get_camera();
    const Transform3d& view_matrix = camera.get_view_matrix();
    const Transform3d& proj_matrix = camera.get_projection_matrix();
    const Size         sz          = get_canvas_size();
 
    shader->start_using();
    shader->set_uniform("offset", OpenGLManager::get_gl_info().is_mesa() ? 0.0005 : 0.00001);
    shader->set_uniform("view_model_matrix", view_matrix);
    shader->set_uniform("projection_matrix", proj_matrix);
 
    glsafe(::glEnable(GL_DEPTH_TEST));
#if !SLIC3R_OPENGL_ES
    if (!OpenGLManager::get_gl_info().is_core_profile())
        glsafe(::glLineWidth(1.0f));
    glsafe(::glPolygonMode(GL_FRONT_AND_BACK, GL_LINE));
#endif
 
    m_volumes.render(GLVolumeCollection::ERenderType::All, false, view_matrix, proj_matrix, sz, [](const GLVolume& volume) {
        return !volume.render_color.is_transparent() || (volume.visible && !volume.is_modifier && volume.color.is_transparent());
    });
 
#if !SLIC3R_OPENGL_ES
    glsafe(::glPolygonMode(GL_FRONT_AND_BACK, GL_FILL));
#endif
    shader->stop_using();
}

References _render_wireframe_overlay(), Slic3r::GLVolumeCollection::All, camera, Slic3r::GLVolume::color, get_canvas_size(), Slic3r::GUI::OpenGLManager::get_gl_info(), GL_DEPTH_TEST, GL_FILL, GL_FRONT_AND_BACK, GL_LINE, glEnable, glLineWidth, glPolygonMode, glsafe, Slic3r::ColorRGBA::is_transparent(), m_volumes, Slic3r::GUI::plater(), Slic3r::GLVolume::render_color, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Referenced by _render_scene(), and _render_wireframe_overlay().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _render_xray_volumes()

void Slic3r::GUI::GLCanvas3D::_render_xray_volumes ( )

private

{
    if (m_volumes.empty())
        return;
 
    GLShaderProgram* shader = wxGetApp().get_shader("xray");
    if (shader == nullptr)
        return;
 
    const Camera&     camera      = wxGetApp().plater()->get_camera();
    const ECanvasType canvas_type = m_canvas_type;
 
    // Depth writes off so every surface along a view ray composites, not just the nearest one, and
    // back faces kept for the far wall of a hollow part. The low, near-uniform coverage the shader
    // emits saturates towards the volume color whatever the order, so the volumes are not sorted.
    glsafe(::glDepthMask(GL_FALSE));
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
    shader->start_using();
    m_volumes.render(GLVolumeCollection::ERenderType::All, true, camera.get_view_matrix(), camera.get_projection_matrix(),
        get_canvas_size(), [this, canvas_type](const GLVolume& volume) {
            if (canvas_type == ECanvasType::CanvasAssembleView)
                return !volume.is_modifier && !volume.is_wipe_tower;
            return m_render_sla_auxiliaries || volume.composite_id.volume_id >= 0;
        });
    shader->stop_using();
 
    glsafe(::glDisable(GL_BLEND));
    glsafe(::glDepthMask(GL_TRUE));
}

References _render_xray_volumes(), Slic3r::GLVolumeCollection::All, camera, CanvasAssembleView, Slic3r::GLVolume::composite_id, get_canvas_size(), GL_BLEND, GL_FALSE, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_TRUE, glBlendFunc, glDepthMask, glDisable, glEnable, glsafe, m_canvas_type, m_render_sla_auxiliaries, m_volumes, Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), and Slic3r::GLVolume::CompositeID::volume_id.

Referenced by _render_objects(), and _render_xray_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _resize()

void Slic3r::GUI::GLCanvas3D::_resize	(	unsigned int	w,
		unsigned int	h )

private

{
    if (m_canvas == nullptr && m_context == nullptr)
        return;
 
    const std::array<unsigned int, 2> new_size = { w, h };
    if (m_old_size == new_size)
        return;
 
    m_old_size = new_size;
 
    auto* imgui = wxGetApp().imgui();
    imgui->set_display_size(static_cast<float>(w), static_cast<float>(h));
 
    //BBS reduce render
    if (m_last_w == w && m_last_h == h) {
        return;
    }
 
    m_last_w = w;
    m_last_h = h;
 
    set_imgui_scaling();
 
    this->request_extra_frame();
 
    // ensures that this canvas is current
    _set_current();
}

References _set_current(), m_canvas, m_context, m_last_h, m_last_w, m_old_size, request_extra_frame(), and set_imgui_scaling().

Referenced by _refresh_if_shown_on_screen(), and _render_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _scene_cache_key()

SceneCache::Key Slic3r::GUI::GLCanvas3D::_scene_cache_key ( const Camera & camera ) const

private

{
    SceneCache::Key key;
    const std::array<int, 4>& viewport = camera.get_viewport();
    key.size = { { (unsigned int)viewport[2], (unsigned int)viewport[3] } };
    key.view_matrix = camera.get_view_matrix();
    key.projection_matrix = camera.get_projection_matrix();
    // Hover reaches the scene only through the sinking contour a hovered volume draws over
    // itself (GLVolumeCollection::render()), the plate icons (PartPlate::render_icons()) and the
    // open gizmo's grabbers.
    for (size_t i = 0; i < m_volumes.volumes.size(); ++i) {
        const GLVolume& volume = *m_volumes.volumes[i];
        if (volume.hover != GLVolume::HS_None && volume.is_sinking() && !volume.is_below_printbed())
            key.sinking_hover_volume_idxs.emplace_back((int)i);
    }
    for (int id : m_hover_plate_idxs) {
        if (id % PartPlate::GRABBER_COUNT != 0)
            key.hover_plate_icon_idxs.emplace_back(id);
    }
    const GLGizmoBase* gizmo = m_gizmos.get_current();
    key.gizmo_hover_id = gizmo != nullptr ? gizmo->get_hover_id() : -1;
    key.render_preview = m_render_preview;
    return key;
}

References _scene_cache_key(), camera, Slic3r::GUI::GLGizmoBase::get_hover_id(), Slic3r::GUI::SceneCache::Key::gizmo_hover_id, Slic3r::GUI::PartPlate::GRABBER_COUNT, Slic3r::GLVolume::hover, Slic3r::GUI::SceneCache::Key::hover_plate_icon_idxs, Slic3r::GLVolume::HS_None, Slic3r::GLVolume::is_below_printbed(), Slic3r::GLVolume::is_sinking(), m_gizmos, m_hover_plate_idxs, m_render_preview, m_volumes, Slic3r::GUI::SceneCache::Key::projection_matrix, Slic3r::GUI::SceneCache::Key::render_preview, Slic3r::GUI::SceneCache::Key::sinking_hover_volume_idxs, Slic3r::GUI::SceneCache::Key::size, and Slic3r::GUI::SceneCache::Key::view_matrix.

Referenced by _can_reuse_cached_scene(), _capture_scene_cache(), and _scene_cache_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _set_current()

bool Slic3r::GUI::GLCanvas3D::_set_current ( )

private

{
    return m_context != nullptr && m_canvas->SetCurrent(*m_context);
}

References m_canvas, and m_context.

Referenced by ~GLCanvas3D(), _render_frame(), _resize(), _set_warning_notification_if_needed(), load_sla_preview(), make_current_for_postinit(), on_gesture(), on_mouse(), reload_scene(), and reset_volumes().

Here is the caller graph for this function:

◆ _set_overlay_as_dirty()

void Slic3r::GUI::GLCanvas3D::_set_overlay_as_dirty ( )

inlineprivate

1526{ m_overlay_dirty = true; }

Slic3r::GUI::GLCanvas3D::m_overlay_dirty

bool m_overlay_dirty

Definition GLCanvas3D.hpp:747

References m_overlay_dirty.

Referenced by on_fps_overlay_timer(), on_key(), Slic3r::GUI::GLCanvas3D::CenterOfMass::on_left_down(), on_mouse(), and Slic3r::GUI::GLCanvas3D::CenterOfMass::render_details().

Here is the caller graph for this function:

◆ _set_shown_canvas_current()

bool Slic3r::GUI::GLCanvas3D::_set_shown_canvas_current ( )

private

{
    // Called before GL work outside render(), where another library's GL context (e.g. WebKitGTK's) can be current.
    // Inside render(), the shown canvas is the one already bound.
    return wxGetApp().plater()->get_current_canvas3D()->_set_current();
}

Referenced by load_gcode_preview(), load_shells(), render_thumbnail(), render_thumbnail(), and reset_gcode_toolpaths().

Here is the caller graph for this function:

◆ _set_warning_notification()

void Slic3r::GUI::GLCanvas3D::_set_warning_notification	(	EWarning	warning,
		bool	state )

private

{
    // Skip on shutdown: Plater's pImpl is already freed, so get_notification_manager() would use-after-free.
    if (wxGetApp().is_closing())
        return;
    using NotificationLevel = NotificationManager::NotificationLevel;
    enum ErrorType{
        PLATER_WARNING,
        PLATER_ERROR,
        SLICING_SERIOUS_WARNING,
        SLICING_ERROR,
        SLICING_LIMIT_ERROR,
        SLICING_HEIGHT_OUTSIDE
    };
    const static std::vector<std::string> extruder_name_list= {_u8L("left nozzle"), _u8L("right nozzle")};  // in ui, we treat extruder as nozzle
    std::string text;
    ErrorType error = ErrorType::PLATER_WARNING;
    const ModelObject* conflictObj=nullptr;
    const ModelInstance* conflictInst=nullptr;
    switch (warning) {
    case EWarning::GCodeConflict: {
        static std::string prevConflictText;
        text  = prevConflictText;
        error = ErrorType::SLICING_SERIOUS_WARNING;
        if (!m_gcode_viewer.m_conflict_result) { break; }
        std::string objName1 = m_gcode_viewer.m_conflict_result.value()._objName1;
        std::string objName2 = m_gcode_viewer.m_conflict_result.value()._objName2;
        double      height   = m_gcode_viewer.m_conflict_result.value()._height;
        int         layer    = m_gcode_viewer.m_conflict_result.value().layer;
        const PrintInstance *inst2 = reinterpret_cast<const PrintInstance *>(m_gcode_viewer.m_conflict_result.value()._obj2);
 
        text = (boost::format(_u8L("Conflicts of G-code paths have been found at layer %d, Z = %.2lfmm. Please separate the conflicted objects farther (%s <-> %s).")) % layer %
                height % objName1 % objName2)
                   .str();
        prevConflictText        = text;
        
        if (inst2) {
            if (inst2->model_instance) conflictInst = inst2->model_instance;
            else if (inst2->print_object) conflictObj = inst2->print_object->model_object();
        }
        break;
    }
    case EWarning::ObjectOutside:      text = _u8L("An object is laid over the plate boundaries."); break;
    case EWarning::ToolHeightOutside:  text = _u8L("A G-code path goes beyond the max print height."); error = ErrorType::SLICING_ERROR; break;
    case EWarning::ToolpathOutside:    text = _u8L("A G-code path goes beyond plate boundaries."); error = ErrorType::SLICING_ERROR; break;
    case EWarning::TPUPrintableError: {
        text = _u8L("Not support printing 2 or more TPU filaments.");
        error = ErrorType::SLICING_ERROR;
        break;
    }
    case EWarning::FilamentPrintableError: {
        text  = filament_printable_error_msg.ToUTF8();
        error = ErrorType::SLICING_ERROR;
        break;
    }
    case EWarning::LeftExtruderPrintableError:
    case EWarning::RightExtruderPrintableError: {
        error = ErrorType::PLATER_ERROR;
        break;
    }
    case EWarning::MultiExtruderPrintableError: {
        for (auto error_iter = m_gcode_viewer.m_gcode_check_result.print_area_error_infos.begin(); error_iter != m_gcode_viewer.m_gcode_check_result.print_area_error_infos.end(); ++error_iter) {
            if (error_iter != m_gcode_viewer.m_gcode_check_result.print_area_error_infos.begin()) {
                text += "\n";
            }
            int extruder_id = error_iter->first + 1; // change extruder id to 1 based
            std::string filaments;
            std::vector<int> slice_error_object_idxs;
            for (size_t i = 0; i < error_iter->second.size(); ++i) {
                if (i > 0) {
                    filaments += ", ";
                }
                int filament_id = error_iter->second[i].first + 1; // change filament id to 1 based
                int object_label_id = error_iter->second[i].second;
 
                filaments += std::to_string(filament_id);
                for (int object_idx = 0; object_idx < (int) m_model->objects.size(); ++object_idx) {
                    const ModelObject *model_object = m_model->objects[object_idx];
                    for (int instance_idx = 0; instance_idx < (int) model_object->instances.size(); ++instance_idx) {
                        const ModelInstance *model_instance = model_object->instances[instance_idx];
                        auto                 expect_id      = model_instance->get_labeled_id();
                        if (object_label_id == expect_id) {
                            slice_error_object_idxs.emplace_back(object_idx);
                        }
                    }
                }
            }
            for (GLVolume *volume : m_gcode_viewer.m_shells.volumes.volumes) {
                for (auto obj_idx : slice_error_object_idxs) {
                    if (volume->object_idx() == obj_idx) {
                        volume->slice_error = true;
                        volume->selected    = true;
                    }
                }
            }
            std::string extruder_name;
            if(wxGetApp().preset_bundle->is_bbl_vendor()){
                extruder_name = extruder_name_list[extruder_id-1];
            }
            else{
                extruder_name += (boost::format(_u8L("Tool %d"))%extruder_id).str();
            }
 
            text += format(_L_PLURAL("Filament %1% is placed in the %2%, but the generated G-code path exceeds the printable range of the %2%.",
                                     "Filaments %1% are placed in the %2%, but the generated G-code path exceeds the printable range of the %2%.",
                                     error_iter->second.size()),
                           filaments, extruder_name);
        }
        error = ErrorType::SLICING_LIMIT_ERROR;
        break;
    }
    case EWarning::MultiExtruderHeightOutside: {
        for (auto error_iter = m_gcode_viewer.m_gcode_check_result.print_height_error_infos.begin(); error_iter != m_gcode_viewer.m_gcode_check_result.print_height_error_infos.end(); ++error_iter) {
            if (error_iter != m_gcode_viewer.m_gcode_check_result.print_height_error_infos.begin()) {
                text += "\n";
            }
            int              extruder_id = error_iter->first + 1; // change extruder id to 1 based
            std::set<int>    filament_ids;
            std::vector<int> slice_error_object_idxs;
            for (size_t i = 0; i < error_iter->second.size(); ++i) {
                int filament_id     = error_iter->second[i].first + 1; // change filament id to 1 based
                int object_label_id = error_iter->second[i].second;
                filament_ids.insert(filament_id);
                for (int object_idx = 0; object_idx < (int) m_model->objects.size(); ++object_idx) {
                    const ModelObject *model_object = m_model->objects[object_idx];
                    for (int instance_idx = 0; instance_idx < (int) model_object->instances.size(); ++instance_idx) {
                        const ModelInstance *model_instance = model_object->instances[instance_idx];
                        auto                 expect_id      = model_instance->get_labeled_id();
                        if (object_label_id == expect_id) {
                            slice_error_object_idxs.emplace_back(object_idx);
                        }
                    }
                }
            }
 
            std::string filaments;
            int         index = 0;
            for (auto filament_id : filament_ids) {
                if (index > 0) {
                    filaments += ", ";
                }
                filaments += std::to_string(filament_id);
                ++index;
            }
 
            for (GLVolume *volume : m_gcode_viewer.m_shells.volumes.volumes) {
                for (auto obj_idx : slice_error_object_idxs) {
                    if (volume->object_idx() == obj_idx) {
                        volume->slice_error = true;
                        volume->selected    = true;
                    }
                }
            }
            std::string extruder_name = extruder_name_list[extruder_id-1];
            text += format(_L_PLURAL("Filament %1% is placed in the %2%, but the generated G-code path exceeds the printable height of the %2%.",
                                     "Filaments %1% are placed in the %2%, but the generated G-code path exceeds the printable height of the %2%.",
                                     filament_ids.size()),
                           filaments, extruder_name);
        }
        if (!text.empty()) {
            text += "\n";
            text += _u8L("Open wiki for more information.");
        }
        error = ErrorType::SLICING_HEIGHT_OUTSIDE;
        break;
    }
 
    // BBS: remove _u8L() for SLA
    case EWarning::SlaSupportsOutside: text = ("SLA supports outside the print area were detected."); error = ErrorType::PLATER_ERROR; break;
    case EWarning::SomethingNotShown:  text = _u8L("Only the object being edited is visible."); break;
    case EWarning::ObjectClashed:
        error = ErrorType::PLATER_ERROR;
        break;
    case EWarning::ObjectLimited:
        text = get_object_limited_text();
        break;
    case EWarning::FilamentUnPrintableOnFirstLayer: {
        std::string             warning;
        const std::vector<int> &conflict_filament = m_gcode_viewer.filament_printable_reuslt.conflict_filament;
        auto                    iter              = conflict_filament.begin();
        for (int filament : conflict_filament) {
            warning += std::to_string(filament + 1);
            warning += " ";
        }
        text  = (boost::format(into_u8(_L_PLURAL("Filament %s cannot be printed directly on the surface of this plate.",
                                                 "Filaments %s cannot be printed directly on the surface of this plate.", conflict_filament.size()))) % warning).str();
        error = ErrorType::SLICING_ERROR;
        break;
    }
    case EWarning::MixUsePLAAndPETG:
        text = _u8L("PLA and PETG filaments detected in the mixture. Adjust parameters according to the Wiki to ensure print quality.");
        break;
    case EWarning::SingleExtruderMixedFilament:
        text = get_single_extruder_mixed_filament_warning_text();
        break;
    case EWarning::PrimeTowerOutside:
        text  = _u8L("The prime tower extends beyond the plate boundary.");
        break;
    case EWarning::NozzleFilamentIncompatible: {
        text = _u8L(get_nozzle_filament_incompatible_text());
        break;
    }
    case EWarning::MixtureFilamentIncompatible: {
        text = _u8L(get_filament_mixture_warning_text());
        break;
    }
    case EWarning::FlushingVolumeZero:
        text = _u8L("Partial flushing volume set to 0. Multi-color printing may cause color mixing in models. Please readjust flushing settings.");
        error = ErrorType::SLICING_ERROR;
        break;
    }
    //BBS: this may happened when exit the app, plater is null
    if (!wxGetApp().plater())
        return;
    auto& notification_manager = *wxGetApp().plater()->get_notification_manager();
 
    switch (error)
    {
    case PLATER_WARNING:
        if (warning == EWarning::MixUsePLAAndPETG) {
            if (state) {
                notification_manager.push_slicing_customize_error_notification(NotificationType::BBLMixUsePLAAndPETG, NotificationLevel::WarningNotificationLevel, text, _u8L("Click Wiki for help."),
                    [](wxEvtHandler*) {
                        std::string language = wxGetApp().app_config->get("language");
                        wxString    region = L"en";
                        if (language.find("zh") == 0)
                          region = L"zh";
                        // Although this link looks like it's only for the H2D, its guidance is generic.
                        wxGetApp().open_browser_with_warning_dialog(wxString::Format(L"https://wiki.bambulab.com/%s/filament-acc/filament/h2d-pla-and-petg-mutual-support", region));
                        return false;
                    });
            }
            else
                notification_manager.close_slicing_customize_error_notification(NotificationType::BBLMixUsePLAAndPETG, NotificationLevel::WarningNotificationLevel);
        }
        else if (warning == EWarning::NozzleFilamentIncompatible){
            if(state){
                notification_manager.push_slicing_customize_error_notification(NotificationType::BBLNozzleFilamentIncompatible, NotificationLevel::WarningNotificationLevel, text);
            }
            else{
                notification_manager.close_slicing_customize_error_notification(NotificationType::BBLNozzleFilamentIncompatible, NotificationLevel::WarningNotificationLevel);
            }
        }
        else if (warning == EWarning::SingleExtruderMixedFilament) {
            // Close by type: check_single_extruder_mixed_filament_risk() clears the shared text
            // buffer on every call, so a close-by-text would miss once the risk is gone.
            if (state)
                notification_manager.push_slicing_customize_error_notification(NotificationType::BBLSingleExtruderMixedFilamentRisk, NotificationLevel::WarningNotificationLevel, text);
            else
                notification_manager.close_slicing_customize_error_notification(NotificationType::BBLSingleExtruderMixedFilamentRisk, NotificationLevel::WarningNotificationLevel);
        }
        else {
            if (state)
                notification_manager.push_plater_warning_notification(text);
            else
                notification_manager.close_plater_warning_notification(text);
        }
        break;
    case PLATER_ERROR:
        if (warning == EWarning::LeftExtruderPrintableError) {
            if (state) {
                if (auto left_str = get_left_extruder_unprintable_text(); !left_str.empty())
                    notification_manager.bbl_show_filament_map_invalid_notification_before_slice(NotificationType::LeftExtruderUnprintableError, left_str);
            }
            else {
                notification_manager.bbl_close_filament_map_invalid_notification_before_slice(NotificationType::LeftExtruderUnprintableError);
            }
        }
        else if (warning == EWarning::RightExtruderPrintableError) {
            if (state) {
                if (auto right_str = get_right_extruder_unprintable_text(); !right_str.empty())
                    notification_manager.bbl_show_filament_map_invalid_notification_before_slice(NotificationType::RightExtruderUnprintableError, right_str);
            }
            else {
                notification_manager.bbl_close_filament_map_invalid_notification_before_slice(NotificationType::RightExtruderUnprintableError);
            }
        }
        else if (warning == EWarning::ObjectClashed) {
            auto str = get_object_clashed_text();
            if(state){
                if (!str.empty())
                    notification_manager.push_plater_error_notification(str);
            }
            else{
                notification_manager.close_plater_error_notification(str);
            }
        }
        else {
            if (state)
                notification_manager.push_plater_error_notification(text);
            else
                notification_manager.close_plater_error_notification(text);
        }
        break;
    case SLICING_SERIOUS_WARNING:
        if (state) {
            if (conflictInst) {
                notification_manager.push_slicing_serious_warning_notification(text, std::vector<ModelInstance const*>{conflictInst});
            } else {
                notification_manager.push_slicing_serious_warning_notification(text, conflictObj ? std::vector<ModelObject const*>{conflictObj} : std::vector<ModelObject const*>{});
            }
        }
        else
            notification_manager.close_slicing_serious_warning_notification(text);
        break;
    case SLICING_ERROR:
        if (warning == EWarning::FilamentUnPrintableOnFirstLayer) {
            if (state) {
                notification_manager.bbl_show_bed_filament_incompatible_notification(text);
            }
            else {
                notification_manager.bbl_close_bed_filament_incompatible_notification();
            }
        }
        if (warning == EWarning::FilamentPrintableError) {
            if (state){
                auto callback = [](wxEvtHandler*) {
                    auto plater = wxGetApp().plater();
                    auto partplate = plater->get_partplate_list().get_curr_plate();
                    try_pop_up_before_slice(false, plater, partplate, true); // ignore the return value
                    return false;
                };
                notification_manager.push_slicing_customize_error_notification(NotificationType::BBLFilamentPrintableError, NotificationLevel::ErrorNotificationLevel, text,  _u8L("Click here to regroup"), callback);
            }
            else
                notification_manager.close_slicing_customize_error_notification(NotificationType::BBLFilamentPrintableError, NotificationLevel::ErrorNotificationLevel);
        }
        else if (warning == EWarning::FlushingVolumeZero) {
            if (state) {
                auto callback = [](wxEvtHandler *) {
                    auto                              plater              = wxGetApp().plater();
                    const wxEventTypeTag<SimpleEvent> EVT_SCHEDULE_BACKGROUND_PROCESS(wxNewEventType());
                    open_flushing_dialog(plater, SimpleEvent(EVT_SCHEDULE_BACKGROUND_PROCESS, plater));
                    plater->get_view3D_canvas3D()->reload_scene(true);
                    return false;
                };
                notification_manager.push_flushing_volume_error_notification(NotificationType::BBLFlushingVolumeZero, NotificationLevel::WarningNotificationLevel, text, _u8L("Flushing Volume"), callback);
            } else
                notification_manager.close_flushing_volume_error_notification(NotificationType::BBLFlushingVolumeZero, NotificationLevel::WarningNotificationLevel);
        }
        else {
            if (state)
                notification_manager.push_slicing_error_notification(text, conflictObj ? std::vector<ModelObject const*>{conflictObj} : std::vector<ModelObject const*>{});
            else
                notification_manager.close_slicing_error_notification(text);
        }
        break;
    case SLICING_LIMIT_ERROR:
        if (state)
            notification_manager.bbl_show_filament_map_invalid_notification_after_slice(NotificationType::BBLSliceLimitError, text);
        else
            notification_manager.bbl_close_filament_map_invalid_notification_after_slice(NotificationType::BBLSliceLimitError);
        break;
    case SLICING_HEIGHT_OUTSIDE:
        if (state)
            notification_manager.push_slicing_customize_error_notification(NotificationType::BBLSliceMultiExtruderHeightOutside, NotificationLevel::ErrorNotificationLevel, text);
        else
            notification_manager.close_slicing_customize_error_notification(NotificationType::BBLSliceMultiExtruderHeightOutside, NotificationLevel::ErrorNotificationLevel);
        break;
    default:
        break;
    }
}

References _L_PLURAL, _set_warning_notification(), _u8L, Slic3r::GUI::BBLFilamentPrintableError, Slic3r::GUI::BBLFlushingVolumeZero, Slic3r::GUI::BBLMixUsePLAAndPETG, Slic3r::GUI::BBLNozzleFilamentIncompatible, Slic3r::GUI::BBLSingleExtruderMixedFilamentRisk, Slic3r::GUI::BBLSliceLimitError, Slic3r::GUI::BBLSliceMultiExtruderHeightOutside, Slic3r::filament_ids(), Slic3r::GUI::filament_printable_error_msg, FilamentPrintableError, FilamentUnPrintableOnFirstLayer, FlushingVolumeZero, Slic3r::format(), GCodeConflict, Slic3r::GUI::get_filament_mixture_warning_text(), Slic3r::ModelInstance::get_labeled_id(), Slic3r::GUI::get_left_extruder_unprintable_text(), Slic3r::GUI::get_nozzle_filament_incompatible_text(), Slic3r::GUI::get_object_clashed_text(), Slic3r::GUI::get_object_limited_text(), Slic3r::GUI::get_right_extruder_unprintable_text(), Slic3r::GUI::get_single_extruder_mixed_filament_warning_text(), Slic3r::ModelObject::instances, Slic3r::into_u8(), L, LeftExtruderPrintableError, Slic3r::GUI::LeftExtruderUnprintableError, m_gcode_viewer, m_model, MixtureFilamentIncompatible, MixUsePLAAndPETG, Slic3r::PrintInstance::model_instance, Slic3r::PrintObjectBase::model_object(), MultiExtruderHeightOutside, MultiExtruderPrintableError, NozzleFilamentIncompatible, Slic3r::GLVolume::object_idx(), ObjectClashed, ObjectLimited, ObjectOutside, open_flushing_dialog(), Slic3r::GUI::plater(), PrimeTowerOutside, Slic3r::PrintInstance::print_object, RightExtruderPrintableError, Slic3r::GUI::RightExtruderUnprintableError, SingleExtruderMixedFilament, SlaSupportsOutside, SomethingNotShown, ToolHeightOutside, ToolpathOutside, TPUPrintableError, and Slic3r::GUI::try_pop_up_before_slice().

Referenced by _set_warning_notification(), _set_warning_notification_if_needed(), reload_scene(), reset_volumes(), and toggle_model_objects_visibility().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _set_warning_notification_if_needed()

void Slic3r::GUI::GLCanvas3D::_set_warning_notification_if_needed ( EWarning warning )

private

{
    _set_current();
    bool show = false;
    if (!m_volumes.empty()) {
        show = _is_any_volume_outside();
        show &= m_gcode_viewer.has_data() && m_gcode_viewer.is_contained_in_bed() && m_gcode_viewer.m_conflict_result.has_value();
    } else {
        if (wxGetApp().is_editor()) {
            if (current_printer_technology() != ptSLA) {
                unsigned int max_z_layer = m_gcode_viewer.get_layers_z_range().back();
                if (warning == EWarning::ToolHeightOutside) // check if max z_layer height exceed max print height
                    // Belt printer with active post-gcode machine-frame transform: layer Z values
                    // live in the machine frame, not the build-volume frame, so the comparison
                    // against printable_height is meaningless.  Suppress the warning entirely.
                    show = m_gcode_viewer.has_data() && !m_gcode_viewer.is_machine_frame_transform_active()
                        && (m_gcode_viewer.get_layers_zs()[max_z_layer] - m_gcode_viewer.get_max_print_height() >= 1e-6);
                else if (warning == EWarning::ToolpathOutside) { // check if max x,y coords exceed bed area
                    show = m_gcode_viewer.has_data() && !m_gcode_viewer.is_contained_in_bed() &&
                           (m_gcode_viewer.get_max_print_height() -m_gcode_viewer.get_layers_zs()[max_z_layer] >= 1e-6);
                }
                else if (warning == EWarning::GCodeConflict)
                    show = m_gcode_viewer.has_data() && m_gcode_viewer.is_contained_in_bed() && m_gcode_viewer.m_conflict_result.has_value();
                else if (warning == EWarning::MultiExtruderPrintableError)
                    show = m_gcode_viewer.has_data() && (m_gcode_viewer.m_gcode_check_result.error_code & 1);
                else if (warning == EWarning::MultiExtruderHeightOutside)
                    show = m_gcode_viewer.has_data() && (m_gcode_viewer.m_gcode_check_result.error_code & (1 << 1));
                else if (warning == EWarning::FilamentUnPrintableOnFirstLayer)
                    show = m_gcode_viewer.has_data() && m_gcode_viewer.filament_printable_reuslt.has_value();
            }
        }
    }
 
    _set_warning_notification(warning, show);
}

References _is_any_volume_outside(), _set_current(), _set_warning_notification(), _set_warning_notification_if_needed(), current_printer_technology(), FilamentUnPrintableOnFirstLayer, GCodeConflict, m_gcode_viewer, m_volumes, MultiExtruderHeightOutside, MultiExtruderPrintableError, Slic3r::ptSLA, ToolHeightOutside, and ToolpathOutside.

Referenced by _set_warning_notification_if_needed(), _update_slice_error_status(), and load_sla_preview().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _shadow_casters_signature()

size_t Slic3r::GUI::GLCanvas3D::_shadow_casters_signature ( bool toolpath_casters ) const

private

{
    if (toolpath_casters)
        return m_gcode_viewer.shadow_casters_signature();
 
    size_t hash = 1;
    for (const GLVolume* volume : m_volumes.volumes) {
        if (volume == nullptr || !volume->is_active || !volume->printable || volume->is_modifier || volume->is_wipe_tower)
            continue;
        boost::hash_combine(hash, volume);
        boost::hash_combine(hash, volume->model.vertices_count());
        boost::hash_combine(hash, volume->model.indices_count());
        const BoundingBoxf3& bb = volume->model.get_bounding_box();
        for (double value : { bb.min.x(), bb.min.y(), bb.min.z(), bb.max.x(), bb.max.y(), bb.max.z() })
            boost::hash_combine(hash, value);
        const Transform3d world = volume->world_matrix();
        for (int i = 0; i < 16; ++i)
            boost::hash_combine(hash, world.matrix().data()[i]);
    }
    return hash;
}

References _shadow_casters_signature(), Slic3r::GUI::GLModel::get_bounding_box(), Slic3r::GUI::GLModel::indices_count(), m_gcode_viewer, m_volumes, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::GLVolume::model, Slic3r::GUI::GLModel::vertices_count(), and Slic3r::GLVolume::world_matrix().

Referenced by _render_shadows(), and _shadow_casters_signature().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _shadow_mode()

GLCanvas3D::EShadowMode Slic3r::GUI::GLCanvas3D::_shadow_mode ( ) const

private

{
    const std::string mode = wxGetApp().app_config != nullptr ? wxGetApp().app_config->get(SETTING_OPENGL_REALISTIC_SHADOWS) : std::string();
    return mode == "static" ? EShadowMode::Static : mode == "orbit" ? EShadowMode::Orbit : EShadowMode::Off;
}

References _shadow_mode(), Off, Orbit, SETTING_OPENGL_REALISTIC_SHADOWS, and Static.

Referenced by _render_gcode(), _render_shadows(), _shadow_mode(), and _static_light_dir_eye().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _start_timer()

void Slic3r::GUI::GLCanvas3D::_start_timer ( )

inlineprivate

1634{ m_timer.Start(100, wxTIMER_CONTINUOUS); }

References m_timer.

Referenced by _perform_layer_editing_action().

Here is the caller graph for this function:

◆ _static_light_dir_eye()

std::optional< Vec3d > Slic3r::GUI::GLCanvas3D::_static_light_dir_eye ( ) const

private

{
    if (!_is_realistic_view_enabled() || _shadow_mode() != EShadowMode::Static)
        return std::nullopt;
    const Matrix3d view_rot = wxGetApp().plater()->get_camera().get_view_matrix().matrix().block<3, 3>(0, 0);
    return Vec3d((view_rot * STATIC_LIGHT_DIR).normalized());
}

References _is_realistic_view_enabled(), _shadow_mode(), _static_light_dir_eye(), Static, and Slic3r::GUI::STATIC_LIGHT_DIR.

Referenced by _render_gcode(), _render_objects(), and _static_light_dir_eye().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _stop_timer()

void Slic3r::GUI::GLCanvas3D::_stop_timer ( )

inlineprivate

1635{ m_timer.Stop(); }

References m_timer.

Referenced by on_mouse().

Here is the caller graph for this function:

◆ _switch_toolbars_icon_filename()

void Slic3r::GUI::GLCanvas3D::_switch_toolbars_icon_filename ( )

private

{
    BackgroundTexture::Metadata background_data;
    background_data.filename = m_is_dark ? "toolbar_background_dark.png" : "toolbar_background.png";
    background_data.left = 16;
    background_data.top = 16;
    background_data.right = 16;
    background_data.bottom = 16;
    m_main_toolbar.init(background_data);
    m_assemble_view_toolbar.init(background_data);
    m_separator_toolbar.init(background_data);
    collapse_toolbar().init(background_data);
 
    // main toolbar
    {
        GLToolbarItem* item;
        item = m_main_toolbar.get_item("add");
        item->set_icon_filename(m_is_dark ? "toolbar_open_dark.svg" : "toolbar_open.svg");
 
        item = m_main_toolbar.get_item("addplate");
        item->set_icon_filename(m_is_dark ? "toolbar_add_plate_dark.svg" : "toolbar_add_plate.svg");
 
        item = m_main_toolbar.get_item("orient");
        item->set_icon_filename(m_is_dark ? "toolbar_orient_dark.svg" : "toolbar_orient.svg");
 
        item = m_main_toolbar.get_item("addplate");
        item->set_icon_filename(m_is_dark ? "toolbar_add_plate_dark.svg" : "toolbar_add_plate.svg");
 
        item = m_main_toolbar.get_item("arrange");
        item->set_icon_filename(m_is_dark ? "toolbar_arrange_dark.svg" : "toolbar_arrange.svg");
 
        item = m_main_toolbar.get_item("more");
        item->set_icon_filename(m_is_dark ? "instance_add_dark.svg" : "instance_add.svg");
 
        item = m_main_toolbar.get_item("fewer");
        item->set_icon_filename(m_is_dark ? "instance_remove_dark.svg" : "instance_remove.svg");
 
        item = m_main_toolbar.get_item("splitobjects");
        item->set_icon_filename(m_is_dark ? "split_objects_dark.svg" : "split_objects.svg");
 
        item = m_main_toolbar.get_item("splitvolumes");
        item->set_icon_filename(m_is_dark ? "split_parts_dark.svg" : "split_parts.svg");
 
        item = m_main_toolbar.get_item("layersediting");
        item->set_icon_filename(m_is_dark ? "toolbar_variable_layer_height_dark.svg" : "toolbar_variable_layer_height.svg");
    }
 
    // assemble view toolbar
    {
        GLToolbarItem* item;
        item = m_assemble_view_toolbar.get_item("assembly_view");
        item->set_icon_filename(m_is_dark ? "toolbar_assemble_dark.svg" : "toolbar_assemble.svg");
    }
}

References Slic3r::GUI::BackgroundTexture::Metadata::bottom, collapse_toolbar(), Slic3r::GUI::BackgroundTexture::Metadata::filename, Slic3r::GUI::GLToolbar::init(), Slic3r::GUI::BackgroundTexture::Metadata::left, m_assemble_view_toolbar, m_is_dark, m_main_toolbar, m_separator_toolbar, Slic3r::GUI::BackgroundTexture::Metadata::right, Slic3r::GUI::GLToolbarItem::set_icon_filename(), and Slic3r::GUI::BackgroundTexture::Metadata::top.

Referenced by on_change_color_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _update_camera_zoom()

void Slic3r::GUI::GLCanvas3D::_update_camera_zoom ( double zoom )

private

{
    wxGetApp().plater()->get_camera().update_zoom(zoom);
    m_dirty = true;
}

References m_dirty.

Referenced by handle_shortcut(), and on_mouse_wheel().

Here is the caller graph for this function:

◆ _update_imgui_select_plate_toolbar()

bool Slic3r::GUI::GLCanvas3D::_update_imgui_select_plate_toolbar ( )

private

{
    if (!m_sel_plate_toolbar.is_enabled()) {
        return false;
    }
 
    const auto& p_plater = wxGetApp().plater();
    if (!p_plater) {
        return false;
    }
 
    if (!p_plater->is_plate_toolbar_image_dirty()) {
        return false;
    }
 
    if (!p_plater->is_gcode_3mf()) { 
        p_plater->update_all_plate_thumbnails(true);
    }
 
    _update_select_plate_toolbar_stats_item();
 
    m_sel_plate_toolbar.del_all_item();
 
    PartPlateList& plate_list = p_plater->get_partplate_list();
    for (int i = 0; i < plate_list.get_plate_count(); i++) {
        IMToolbarItem* item = new IMToolbarItem();
        if (PartPlate* plate = plate_list.get_plate(i))
            item->set_thumbnail(plate->thumbnail_data);
        m_sel_plate_toolbar.m_items.push_back(item);
    }
    p_plater->clear_plate_toolbar_image_dirty();
    m_sel_plate_toolbar.is_display_scrollbar = false;
    return true;
}

References _update_select_plate_toolbar_stats_item(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GUI::PartPlateList::get_plate_count(), m_sel_plate_toolbar, and Slic3r::GUI::IMToolbarItem::set_thumbnail().

Referenced by _render_imgui_select_plate_toolbar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _update_inactive_plates_visibility()

bool Slic3r::GUI::GLCanvas3D::_update_inactive_plates_visibility ( )

private

{
    const bool hide = _hides_inactive_plates();
    if (!hide && !m_inactive_plates_hidden)
        return false;
 
    PartPlateList& plate_list = wxGetApp().plater()->get_partplate_list();
    PartPlate*     plate      = hide ? plate_list.get_curr_plate() : nullptr;
 
    struct Instance
    {
        BoundingBoxf3 box;
        bool          selected{ false };
    };
    std::map<std::pair<int, int>, Instance> instances;
    if (plate != nullptr)
        for (const GLVolume* volume : m_volumes.volumes) {
            Instance& instance = instances[{ volume->object_idx(), volume->instance_idx() }];
            instance.box.merge(volume->transformed_convex_hull_bounding_box());
            instance.selected |= volume->selected;
        }
 
    // A gizmo that hides the other objects shows them all again when it closes.
    const bool keep_hidden = m_gizmos.is_hiding_instances();
    bool changed    = false;
    bool any_hidden = false;
    std::vector<bool> shown_again(m_volumes.volumes.size(), false);
    for (size_t i = 0; i < m_volumes.volumes.size(); ++i) {
        GLVolume*       volume   = m_volumes.volumes[i];
        const Instance* instance = plate != nullptr ? &instances[{ volume->object_idx(), volume->instance_idx() }] : nullptr;
        if (instance != nullptr && !instance->selected && instance->box.defined && !plate->get_bounding_box().overlap(instance->box)) {
            changed |= volume->is_active;
            volume->is_active       = false;
            volume->on_hidden_plate = true;
        } else if (volume->on_hidden_plate && !keep_hidden) {
            volume->is_active       = true;
            volume->on_hidden_plate = false;
            shown_again[i]          = true;
            changed                 = true;
        }
        any_hidden |= volume->on_hidden_plate;
    }
 
    if (auto* raycasters = get_raycasters_for_picking(SceneRaycaster::EType::Volume))
        for (const std::shared_ptr<SceneRaycasterItem>& item : *raycasters) {
            const int i = SceneRaycaster::decode_id(SceneRaycaster::EType::Volume, item->get_id());
            if (0 <= i && i < int(m_volumes.volumes.size()) && (m_volumes.volumes[i]->on_hidden_plate || shown_again[i]))
                item->set_active(shown_again[i]);
        }
    if (auto* raycasters = get_raycasters_for_picking(SceneRaycaster::EType::Bed))
        for (const std::shared_ptr<SceneRaycasterItem>& item : *raycasters)
            item->set_active(!hide || SceneRaycaster::decode_id(SceneRaycaster::EType::Bed, item->get_id()) / PartPlate::GRABBER_COUNT ==
                                          plate_list.get_curr_plate_index());
 
    m_inactive_plates_hidden = hide || any_hidden;
    return changed;
}

References _hides_inactive_plates(), _update_inactive_plates_visibility(), Slic3r::GUI::SceneRaycaster::Bed, Slic3r::GUI::SceneRaycaster::decode_id(), Slic3r::GUI::PartPlate::get_bounding_box(), Slic3r::GUI::PartPlateList::get_curr_plate(), Slic3r::GUI::PartPlateList::get_curr_plate_index(), get_raycasters_for_picking(), Slic3r::GUI::PartPlate::GRABBER_COUNT, Slic3r::GUI::Instance, Slic3r::GLVolume::instance_idx(), m_gizmos, m_inactive_plates_hidden, m_volumes, Slic3r::GLVolume::object_idx(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::overlap(), Slic3r::GLVolume::transformed_convex_hull_bounding_box(), and Slic3r::GUI::SceneRaycaster::Volume.

Referenced by _render_frame(), and _update_inactive_plates_visibility().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _update_select_plate_toolbar_stats_item()

void Slic3r::GUI::GLCanvas3D::_update_select_plate_toolbar_stats_item ( bool force_selected = false )

                                                                            {
    PartPlateList& plate_list = wxGetApp().plater()->get_partplate_list();
    if (plate_list.get_nonempty_plate_list().size() > 1)
        m_sel_plate_toolbar.show_stats_item = true;
    else
        m_sel_plate_toolbar.show_stats_item = false;
 
    if (force_selected && m_sel_plate_toolbar.show_stats_item && m_sel_plate_toolbar.m_all_plates_stats_item)
        m_sel_plate_toolbar.m_all_plates_stats_item->selected = true;
}

References Slic3r::GUI::PartPlateList::get_nonempty_plate_list(), and m_sel_plate_toolbar.

Referenced by _update_imgui_select_plate_toolbar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _update_selection_from_hover()

void Slic3r::GUI::GLCanvas3D::_update_selection_from_hover ( )

private

{
    bool ctrl_pressed = wxGetKeyState(WXK_CONTROL);
 
    if (m_hover_volume_idxs.empty()) {
        if (!ctrl_pressed && (m_rectangle_selection.get_state() == GLSelectionRectangle::Select))
            m_selection.remove_all();
 
        return;
    }
 
    GLSelectionRectangle::EState state = m_rectangle_selection.get_state();
 
    bool hover_modifiers_only = true;
    for (int i : m_hover_volume_idxs) {
        if (!m_volumes.volumes[i]->is_modifier) {
            hover_modifiers_only = false;
            break;
        }
    }
 
    bool selection_changed = false;
    if (state == GLSelectionRectangle::Select) {
        bool contains_all = true;
        for (int i : m_hover_volume_idxs) {
            if (!m_selection.contains_volume((unsigned int)i)) {
                contains_all = false;
                break;
            }
        }
 
        // the selection is going to be modified (Add)
        if (!contains_all) {
            wxGetApp().plater()->take_snapshot(std::string("Select by rectangle"), UndoRedo::SnapshotType::Selection);
            selection_changed = true;
        }
    }
    else {
        bool contains_any = false;
        for (int i : m_hover_volume_idxs) {
            if (m_selection.contains_volume((unsigned int)i)) {
                contains_any = true;
                break;
            }
        }
 
        // the selection is going to be modified (Remove)
        if (contains_any) {
            wxGetApp().plater()->take_snapshot(std::string("Unselect by rectangle"), UndoRedo::SnapshotType::Selection);
            selection_changed = true;
        }
    }
 
    if (!selection_changed)
        return;
 
    Plater::SuppressSnapshots suppress(wxGetApp().plater());
 
    if ((state == GLSelectionRectangle::Select) && !ctrl_pressed)
        m_selection.clear();
 
    for (int i : m_hover_volume_idxs) {
        if (state == GLSelectionRectangle::Select) {
            if (hover_modifiers_only) {
                const GLVolume& v = *m_volumes.volumes[i];
                m_selection.add_volume(v.object_idx(), v.volume_idx(), v.instance_idx(), false);
            }
            else
                m_selection.add(i, false);
        }
        else
            m_selection.remove(i);
    }
 
    if (m_selection.is_empty())
        m_gizmos.reset_all_states();
    else
        m_gizmos.refresh_on_off_state();
 
    m_gizmos.update_data();
    post_event(SimpleEvent(EVT_GLCANVAS_OBJECT_SELECT));
    m_dirty = true;
}

References _update_selection_from_hover(), Slic3r::GLVolume::instance_idx(), m_dirty, m_gizmos, m_hover_volume_idxs, m_rectangle_selection, m_selection, m_volumes, Slic3r::GLVolume::object_idx(), Slic3r::GUI::plater(), post_event(), Slic3r::GUI::GLSelectionRectangle::Select, Slic3r::UndoRedo::Selection, and Slic3r::GLVolume::volume_idx().

Referenced by _update_selection_from_hover(), on_key(), and on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _update_sla_shells_outside_state()

void Slic3r::GUI::GLCanvas3D::_update_sla_shells_outside_state ( )

inlineprivate

1639{ check_volumes_outside_state(); }

Slic3r::GUI::GLCanvas3D::check_volumes_outside_state

ModelInstanceEPrintVolumeState check_volumes_outside_state(ObjectFilamentResults *object_results=nullptr) const

Definition GLCanvas3D.cpp:1971

References check_volumes_outside_state().

Referenced by load_sla_preview().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _update_slice_error_status()

void Slic3r::GUI::GLCanvas3D::_update_slice_error_status ( )

private

{
    _set_warning_notification_if_needed(EWarning::ToolHeightOutside);
    _set_warning_notification_if_needed(EWarning::ToolpathOutside);
    _set_warning_notification_if_needed(EWarning::GCodeConflict);
    _set_warning_notification_if_needed(EWarning::MultiExtruderPrintableError);
    _set_warning_notification_if_needed(EWarning::MultiExtruderHeightOutside);
    _set_warning_notification_if_needed(EWarning::FilamentUnPrintableOnFirstLayer);
}

References _set_warning_notification_if_needed(), FilamentUnPrintableOnFirstLayer, GCodeConflict, MultiExtruderHeightOutside, MultiExtruderPrintableError, ToolHeightOutside, and ToolpathOutside.

Referenced by load_gcode_preview(), and reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _update_volumes_hover_state()

void Slic3r::GUI::GLCanvas3D::_update_volumes_hover_state ( )

private

{
    for (GLVolume* v : m_volumes.volumes) {
        v->hover = GLVolume::HS_None;
    }
 
    if (m_hover_volume_idxs.empty())
        return;
 
    bool ctrl_pressed = wxGetKeyState(WXK_CONTROL); // additive select/deselect
    bool shift_pressed = wxGetKeyState(WXK_SHIFT);  // select by rectangle
    bool alt_pressed = wxGetKeyState(WXK_ALT);      // deselect by rectangle
 
    if (alt_pressed && (shift_pressed || ctrl_pressed)) {
        // illegal combinations of keys
        m_hover_volume_idxs.clear();
        return;
    }
 
    bool selection_modifiers_only = m_selection.is_empty() || m_selection.is_any_modifier();
 
    bool hover_modifiers_only = true;
    for (int i : m_hover_volume_idxs) {
        if (!m_volumes.volumes[i]->is_modifier) {
            hover_modifiers_only = false;
            break;
        }
    }
 
    std::set<std::pair<int, int>> hover_instances;
    for (int i : m_hover_volume_idxs) {
        const GLVolume& v = *m_volumes.volumes[i];
        hover_instances.insert(std::make_pair(v.object_idx(), v.instance_idx()));
    }
 
    bool hover_from_single_instance = hover_instances.size() == 1;
 
    if (hover_modifiers_only && !hover_from_single_instance) {
        // do not allow to select volumes from different instances
        m_hover_volume_idxs.clear();
        return;
    }
 
    for (int i : m_hover_volume_idxs) {
        GLVolume& volume = *m_volumes.volumes[i];
        if (volume.hover != GLVolume::HS_None)
            continue;
 
        bool deselect = volume.selected && ((ctrl_pressed && !shift_pressed) || alt_pressed);
        // (volume->is_modifier && !selection_modifiers_only && !is_ctrl_pressed) -> allows hovering on selected modifiers belonging to selection of type Instance
        bool select = (!volume.selected || (volume.is_modifier && !selection_modifiers_only && !ctrl_pressed)) && !alt_pressed;
 
        if (select || deselect) {
            bool as_volume =
                volume.is_modifier && hover_from_single_instance && !ctrl_pressed &&
                (
                (!deselect) ||
                (deselect && !m_selection.is_single_full_instance() && (volume.object_idx() == m_selection.get_object_idx()) && (volume.instance_idx() == m_selection.get_instance_idx()))
                );
 
            if (as_volume)
                volume.hover = deselect ? GLVolume::HS_Deselect : GLVolume::HS_Select;
            else {
                int object_idx = volume.object_idx();
                int instance_idx = volume.instance_idx();
 
                for (GLVolume* v : m_volumes.volumes) {
                    if (v->object_idx() == object_idx && v->instance_idx() == instance_idx)
                        v->hover = deselect ? GLVolume::HS_Deselect : GLVolume::HS_Select;
                }
            }
        }
        else if (volume.selected)
            volume.hover = GLVolume::HS_Hover;
    }
}

References _update_volumes_hover_state(), Slic3r::GLVolume::hover, Slic3r::GLVolume::HS_Deselect, Slic3r::GLVolume::HS_Hover, Slic3r::GLVolume::HS_None, Slic3r::GLVolume::HS_Select, Slic3r::GLVolume::instance_idx(), m_hover_volume_idxs, m_selection, m_volumes, and Slic3r::GLVolume::object_idx().

Referenced by _picking_pass(), and _update_volumes_hover_state().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _zoom_to_box()

void Slic3r::GUI::GLCanvas3D::_zoom_to_box	(	const BoundingBoxf3 &	box,
		double	margin_factor = DefaultCameraZoomToBoxMarginFactor )

private

{
    wxGetApp().plater()->get_camera().zoom_to_box(box, margin_factor);
    m_dirty = true;
}

References m_dirty.

Referenced by _render_canvas_toolbar(), zoom_to_bed(), zoom_to_gcode(), zoom_to_plate(), zoom_to_selection(), and zoom_to_volumes().

Here is the caller graph for this function:

◆ adaptive_layer_height_profile()

void Slic3r::GUI::GLCanvas3D::adaptive_layer_height_profile ( float quality_factor )

{
    wxGetApp().plater()->take_snapshot("Variable layer height - Adaptive");
    m_layers_editing.adaptive_layer_height_profile(*this, quality_factor);
    m_layers_editing.state = LayersEditing::Completed;
    m_dirty = true;
}

References Slic3r::GUI::GLCanvas3D::LayersEditing::Completed, m_dirty, and m_layers_editing.

◆ add_raycaster_for_picking()

std::shared_ptr< SceneRaycasterItem > Slic3r::GUI::GLCanvas3D::add_raycaster_for_picking	(	SceneRaycaster::EType	type,
		int	id,
		const MeshRaycaster &	raycaster,
		const Transform3d &	trafo = Transform3d::Identity(),
		bool	use_back_faces = false )

inline

                                                                                       {
        return m_scene_raycaster.add_raycaster(type, id, raycaster, trafo, use_back_faces);
    }

References m_scene_raycaster.

Referenced by Slic3r::GUI::register_model_for_picking(), reload_scene(), and Slic3r::GUI::GLGizmoBase::Grabber::render().

Here is the caller graph for this function:

◆ align_section_view_to_camera()

void Slic3r::GUI::GLCanvas3D::align_section_view_to_camera ( )

{
    m_section_view->normal = -wxGetApp().plater()->get_camera().get_dir_forward();
    _on_section_view_changed();
}

References _on_section_view_changed(), and m_section_view.

Referenced by _render_canvas_toolbar(), _render_section_view_panel(), and set_section_view_ratio().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ allow_multisample()

void Slic3r::GUI::GLCanvas3D::allow_multisample ( bool allow )

inline

1124{ m_multisample_allowed = allow; }

References m_multisample_allowed.

◆ apply_retina_scale()

void Slic3r::GUI::GLCanvas3D::apply_retina_scale ( Vec2d & screen_coordinate ) const

{
#if ENABLE_RETINA_GL
    double scale = static_cast<double>(m_retina_helper->get_scale_factor());
    screen_coordinate *= scale;
#endif // ENABLE_RETINA_GL
}

References scale().

Referenced by on_gesture(), Slic3r::GUI::PlaterDropTarget::OnDropFiles(), and Slic3r::GUI::Plater::priv::show_right_click_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_selection_move()

void Slic3r::GUI::GLCanvas3D::apply_selection_move	(	bool	slow,
		bool	camera_space )

{
    m_selection.setup_cache();
    const double multiplier = slow ? 1.0 : 10.0;
 
    Vec3d displacement;
    if (camera_space) {
        Eigen::Matrix<double, 3, 3, Eigen::DontAlign> inv_view_3x3 = wxGetApp().plater()->get_camera().get_view_matrix().inverse().matrix().block(0, 0, 3, 3);
        displacement = multiplier * (inv_view_3x3 * m_selection_edit.direction);
        displacement.z() = 0.0;
    }
    else
        displacement = multiplier * m_selection_edit.direction;
 
    TransformationType trafo_type;
    trafo_type.set_relative();
    m_selection.translate(displacement, trafo_type);
    m_dirty = true;
}

References m_dirty, m_selection, m_selection_edit, and Slic3r::GUI::TransformationType::set_relative().

Referenced by handle_shortcut(), and on_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_selection_rotate()

void Slic3r::GUI::GLCanvas3D::apply_selection_rotate ( double angle_z_rad )

{
    m_selection.setup_cache();
    m_selection.rotate(angle_z_rad * m_selection_edit.direction, TransformationType(TransformationType::World_Relative_Joint));
    m_dirty = true;
}

References m_dirty, m_selection, m_selection_edit, and Slic3r::GUI::TransformationType::World_Relative_Joint.

Referenced by handle_shortcut().

Here is the caller graph for this function:

◆ are_labels_shown()

bool Slic3r::GUI::GLCanvas3D::are_labels_shown ( ) const

inline

1402{ return m_labels.is_shown(); }

References m_labels.

◆ bed_shape_changed()

void Slic3r::GUI::GLCanvas3D::bed_shape_changed ( )

{
    refresh_camera_scene_box();
    wxGetApp().plater()->get_camera().requires_zoom_to_bed = true;
    m_dirty = true;
}

References m_dirty, and refresh_camera_scene_box().

Here is the call graph for this function:

◆ bind_event_handlers()

void Slic3r::GUI::GLCanvas3D::bind_event_handlers ( )

{
    if (m_canvas != nullptr) {
        m_canvas->Bind(wxEVT_SIZE, &GLCanvas3D::on_size, this);
        m_canvas->Bind(wxEVT_IDLE, &GLCanvas3D::on_idle, this);
        m_canvas->Bind(wxEVT_CHAR, &GLCanvas3D::on_char, this);
        m_canvas->Bind(wxEVT_KEY_DOWN, &GLCanvas3D::on_key, this);
        m_canvas->Bind(wxEVT_KEY_UP, &GLCanvas3D::on_key, this);
        m_canvas->Bind(wxEVT_MOUSEWHEEL, &GLCanvas3D::on_mouse_wheel, this);
        m_canvas->Bind(wxEVT_TIMER, &GLCanvas3D::on_timer, this);
        m_canvas->Bind(EVT_GLCANVAS_RENDER_TIMER, &GLCanvas3D::on_render_timer, this);
        m_toolbar_highlighter.set_timer_owner(m_canvas, 0);
        m_canvas->Bind(EVT_GLCANVAS_TOOLBAR_HIGHLIGHTER_TIMER, [this](wxTimerEvent&) { m_toolbar_highlighter.blink(); });
        m_gizmo_highlighter.set_timer_owner(m_canvas, 0);
        m_canvas->Bind(EVT_GLCANVAS_GIZMO_HIGHLIGHTER_TIMER, [this](wxTimerEvent&) { m_gizmo_highlighter.blink(); });
        m_canvas->Bind(wxEVT_LEFT_DOWN, &GLCanvas3D::on_mouse, this);
        m_canvas->Bind(wxEVT_LEFT_UP, &GLCanvas3D::on_mouse, this);
        m_canvas->Bind(wxEVT_MIDDLE_DOWN, &GLCanvas3D::on_mouse, this);
        m_canvas->Bind(wxEVT_MIDDLE_UP, &GLCanvas3D::on_mouse, this);
        m_canvas->Bind(wxEVT_RIGHT_DOWN, &GLCanvas3D::on_mouse, this);
        m_canvas->Bind(wxEVT_RIGHT_UP, &GLCanvas3D::on_mouse, this);
        m_canvas->Bind(wxEVT_MOTION, &GLCanvas3D::on_mouse, this);
        m_canvas->Bind(wxEVT_ENTER_WINDOW, &GLCanvas3D::on_mouse, this);
        m_canvas->Bind(wxEVT_LEAVE_WINDOW, &GLCanvas3D::on_mouse, this);
        m_canvas->Bind(wxEVT_LEFT_DCLICK, &GLCanvas3D::on_mouse, this);
        m_canvas->Bind(wxEVT_MIDDLE_DCLICK, &GLCanvas3D::on_mouse, this);
        m_canvas->Bind(wxEVT_RIGHT_DCLICK, &GLCanvas3D::on_mouse, this);
        m_canvas->Bind(wxEVT_PAINT, &GLCanvas3D::on_paint, this);
        m_canvas->Bind(wxEVT_SET_FOCUS, &GLCanvas3D::on_set_focus, this);
        m_canvas->Bind(wxEVT_KILL_FOCUS, [this](wxFocusEvent& evt) {
                // The key-up that would commit a keyboard edit goes to whatever took the focus.
                if (m_selection_edit.kind != SelectionEdit::None)
                    finish_selection_edit();
                release_held_modifiers();
                wxGetApp().imgui()->forget_key_claims();
#ifdef __APPLE__
                // ImGuiWrapper stops updating the view once it is no longer the IME target.
                if (ImGui::GetIO().ImeWindowHandle == m_canvas->GetHandle()) {
                    mac_ime_set_active(m_canvas->GetHandle(), false);
                    ImGui::GetIO().ImeWindowHandle = nullptr;
                }
#endif
                ImGui::SetWindowFocus(nullptr);
                render();
                evt.Skip();
            });
        // ORCA If the mouse capture is lost while a button is held (Alt+Tab, dialog, lock screen), the button-up
        // never arrives and ImGui keeps the widget active. Cancel the interaction: clear the active widget
        // before releasing the buttons so the release is not taken as a click.
        m_canvas->Bind(wxEVT_MOUSE_CAPTURE_LOST, [this](wxMouseCaptureLostEvent&) {
                if (GImGui != nullptr) {
                    ImGui::ClearActiveID();
                    ImGuiIO& io = ImGui::GetIO();
                    for (bool& down : io.MouseDown)
                        down = false;
                }
                m_navigator_dragging = false;
                render();
            });
        m_event_handlers_bound = true;
 
        m_canvas->Bind(wxEVT_GESTURE_PAN, &GLCanvas3D::on_gesture, this);
        m_canvas->Bind(wxEVT_GESTURE_ZOOM, &GLCanvas3D::on_gesture, this);
        m_canvas->Bind(wxEVT_GESTURE_ROTATE, &GLCanvas3D::on_gesture, this);
        m_canvas->EnableTouchEvents(wxTOUCH_ZOOM_GESTURE | wxTOUCH_ROTATE_GESTURE);
#if __WXOSX__
        initGestures(m_canvas->GetHandle(), m_canvas); // for UIPanGestureRecognizer allowedScrollTypesMask
#endif
    }
}

References finish_selection_edit(), Slic3r::GUI::initGestures(), m_canvas, m_event_handlers_bound, m_gizmo_highlighter, m_navigator_dragging, m_selection_edit, m_toolbar_highlighter, Slic3r::GUI::mac_ime_set_active(), Slic3r::GUI::GLCanvas3D::SelectionEdit::None, on_char(), on_gesture(), on_idle(), on_key(), on_mouse(), on_mouse_wheel(), on_paint(), on_render_timer(), on_set_focus(), on_size(), on_timer(), release_held_modifiers(), and render().

Here is the call graph for this function:

◆ can_sequential_clearance_show_in_gizmo()

bool Slic3r::GUI::GLCanvas3D::can_sequential_clearance_show_in_gizmo ( )

                                                        {
    switch (m_gizmos.get_current_type()) {
    case GLGizmosManager::EType::Move:
    case GLGizmosManager::EType::Scale:
    case GLGizmosManager::EType::Rotate: {
        return true;
    }
    }
    return false;
}

References m_gizmos, Slic3r::GUI::GLGizmosManager::Move, Slic3r::GUI::GLGizmosManager::Rotate, and Slic3r::GUI::GLGizmosManager::Scale.

Referenced by _render_sequential_clearance(), and on_mouse().

Here is the caller graph for this function:

◆ check_volumes_outside_state() [1/3]

void Slic3r::GUI::GLCanvas3D::check_volumes_outside_state ( GLVolumeCollection & volumes ) const

inline

996{ check_volumes_outside_state(volumes, nullptr, false); }

References check_volumes_outside_state().

Referenced by check_volumes_outside_state().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_volumes_outside_state() [2/3]

bool Slic3r::GUI::GLCanvas3D::check_volumes_outside_state	(	GLVolumeCollection &	volumes,
		ModelInstanceEPrintVolumeState *	out_state,
		bool	selection_only = true ) const

private

◆ check_volumes_outside_state() [3/3]

ModelInstanceEPrintVolumeState Slic3r::GUI::GLCanvas3D::check_volumes_outside_state ( ObjectFilamentResults * object_results = nullptr ) const

{
    //BBS: if not initialized, return inside directly insteadof assert
    if (!m_initialized) {
        return ModelInstancePVS_Inside;
    }
    //assert(m_initialized);
 
    ModelInstanceEPrintVolumeState state;
    m_volumes.check_outside_state(m_bed.build_volume(), &state, object_results);
 
    construct_error_string(*object_results, get_object_clashed_text());
    construct_extruder_unprintable_error(*object_results, get_left_extruder_unprintable_text(), get_right_extruder_unprintable_text());
    return state;
}

References Slic3r::GUI::construct_error_string(), Slic3r::GUI::construct_extruder_unprintable_error(), Slic3r::GUI::get_left_extruder_unprintable_text(), Slic3r::GUI::get_object_clashed_text(), Slic3r::GUI::get_right_extruder_unprintable_text(), m_bed, m_initialized, m_volumes, and Slic3r::ModelInstancePVS_Inside.

Referenced by _update_sla_shells_outside_state(), and Slic3r::GUI::Plater::priv::set_current_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_popup_menu_position()

void Slic3r::GUI::GLCanvas3D::clear_popup_menu_position ( )

inline

1311{ m_popup_menu_positon.reset(); }

Slic3r::GUI::GLCanvas3D::m_popup_menu_positon

std::optional< Vec2d > m_popup_menu_positon

Definition GLCanvas3D.hpp:1308

References m_popup_menu_positon.

Referenced by Slic3r::GUI::Plater::priv::show_right_click_menu().

Here is the caller graph for this function:

◆ clicked_button_matches_action()

bool Slic3r::GUI::GLCanvas3D::clicked_button_matches_action	(	const wxMouseEvent &	evt,
		MouseAction	action,
		const std::map< MouseButton, MouseAction > &	mappings ) const

{
    MouseButton clicked = MouseButton::None;
    if (evt.LeftIsDown()) {
        clicked = MouseButton::Left;
    }
    if (evt.MiddleIsDown()) {
        clicked = MouseButton::Middle;
    }
    if (evt.RightIsDown()) {
        clicked = MouseButton::Right;
    }
 
    auto it = mappings.find(clicked);
    if (it == mappings.end()) {
        return false;
    }
    return it->second == action;
}

References Left, Middle, None, Right, and Slic3r::GUI::wxMouseEvent.

Referenced by is_camera_pan(), and is_camera_rotate().

Here is the caller graph for this function:

◆ collapse_side()

CollapseSide Slic3r::GUI::GLCanvas3D::collapse_side ( ) const

private

{
    if (m_collapse_side)
        return m_collapse_side();
    switch (wxGetApp().plater()->get_sidebar_docking_state()) {
    case Sidebar::Left: return CollapseSide::Left;
    case Sidebar::Right: return CollapseSide::Right;
    default: return CollapseSide::None;
    }
}

References Slic3r::GUI::Left, Slic3r::GUI::Sidebar::Left, m_collapse_side, Slic3r::GUI::None, Slic3r::GUI::plater(), Slic3r::GUI::Right, and Slic3r::GUI::Sidebar::Right.

Referenced by _check_and_update_toolbar_icon_scale(), _render_collapse_toolbar(), get_collapse_toolbar_height(), get_collapse_toolbar_width(), and is_collapse_toolbar_on_left().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collapse_toolbar()

GLToolbar & Slic3r::GUI::GLCanvas3D::collapse_toolbar ( ) const

private

{
    return m_collapse_toolbar != nullptr ? *m_collapse_toolbar : wxGetApp().plater()->get_collapse_toolbar();
}

References m_collapse_toolbar.

Referenced by _check_and_update_toolbar_icon_scale(), _deactivate_collapse_toolbar_items(), _overlay_signature(), _render_collapse_toolbar(), _render_frame(), _switch_toolbars_icon_filename(), get_collapse_toolbar_height(), get_collapse_toolbar_width(), on_change_color_mode(), on_idle(), and on_mouse().

Here is the caller graph for this function:

◆ current_printer_technology()

PrinterTechnology Slic3r::GUI::GLCanvas3D::current_printer_technology ( ) const

private

                                                               {
    return m_process->current_printer_technology();
}

References current_printer_technology(), and m_process.

Referenced by _init_main_toolbar(), _render_arrange_menu(), _render_background(), _render_orient_menu(), _render_sla_slices(), _set_warning_notification_if_needed(), current_printer_technology(), do_move(), get_arrange_settings(), get_orient_settings(), on_gesture(), on_mouse(), reload_scene(), toggle_sla_auxiliaries_visibility(), update_compacted_wipe_tower_clearance(), and update_sequential_clearance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_selected()

void Slic3r::GUI::GLCanvas3D::delete_selected ( )

inline

1242{ m_selection.erase(); }

References m_selection.

◆ deselect_all()

void Slic3r::GUI::GLCanvas3D::deselect_all ( )

{
    m_selection.remove_all();
    // BBS
    //wxGetApp().obj_manipul()->set_dirty();
    m_gizmos.reset_all_states();
    m_gizmos.update_data();
    post_event(SimpleEvent(EVT_GLCANVAS_OBJECT_SELECT));
}

References m_gizmos, m_selection, and post_event().

Referenced by on_char(), and on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_center()

void Slic3r::GUI::GLCanvas3D::do_center ( )

{
    if (m_model == nullptr)
        return;
 
    m_selection.center();
}

References m_model, and m_selection.

◆ do_center_plate()

void Slic3r::GUI::GLCanvas3D::do_center_plate ( const int plate_idx )

                                                    {
    if (m_model == nullptr)
        return;
 
    m_selection.center_plate(plate_idx);
}

References m_model, and m_selection.

◆ do_drop()

void Slic3r::GUI::GLCanvas3D::do_drop ( )

{
    if (m_model == nullptr)
        return;
 
    m_selection.drop();
}

References m_model, and m_selection.

◆ do_mirror()

void Slic3r::GUI::GLCanvas3D::do_mirror ( const std::string & snapshot_type )

{
    if (m_model == nullptr)
        return;
 
    if (!snapshot_type.empty())
        wxGetApp().plater()->take_snapshot(snapshot_type);
 
    // stores current min_z of instances
    std::map<std::pair<int, int>, double> min_zs;
    if (!snapshot_type.empty()) {
        for (int i = 0; i < static_cast<int>(m_model->objects.size()); ++i) {
            const ModelObject* obj = m_model->objects[i];
            for (int j = 0; j < static_cast<int>(obj->instances.size()); ++j) {
                min_zs[{ i, j }] = obj->instance_bounding_box(j).min.z();
            }
        }
    }
 
    std::set<std::pair<int, int>> done;  // keeps track of modified instances
 
    Selection::EMode selection_mode = m_selection.get_mode();
 
    for (const GLVolume* v : m_volumes.volumes) {
        int object_idx = v->object_idx();
        if (object_idx < 0 || (int)m_model->objects.size() <= object_idx)
            continue;
 
        int instance_idx = v->instance_idx();
        int volume_idx = v->volume_idx();
 
        done.insert(std::pair<int, int>(object_idx, instance_idx));
 
        // Mirror instances/volumes
        ModelObject* model_object = m_model->objects[object_idx];
        if (model_object == nullptr)
            continue;
 
        if (selection_mode == Selection::Instance)
            model_object->instances[instance_idx]->set_transformation(v->get_instance_transformation());
        else if (selection_mode == Selection::Volume) {
            if (model_object->volumes[volume_idx]->get_transformation() != v->get_volume_transformation()) {
                model_object->volumes[volume_idx]->set_transformation(v->get_volume_transformation());
                // BBS: backup
                Slic3r::save_object_mesh(*model_object);
            }
        }
 
        model_object->invalidate_bounding_box();
    }
 
    //BBS: notify instance updates to part plater list
    m_selection.notify_instance_update(-1, -1);
 
    // Fixes sinking/flying instances (snaps object to buildplate)
    for (const std::pair<int, int>& i : done) {
        ModelObject* mo = m_model->objects[i.first];
 
        //BBS: don't call translate if the z is zero
        double shift_z = mo->get_instance_min_z(i.second);
        // leave sinking instances as sinking
        if (mo->auto_drop && (min_zs.empty() || min_zs.find({ i.first, i.second })->second >= SINKING_Z_THRESHOLD || shift_z > SINKING_Z_THRESHOLD) && (shift_z != 0.0f)) {
            Vec3d shift(0.0, 0.0, -shift_z);
            m_selection.translate(i.first, i.second, shift);
            mo->translate_instance(i.second, shift);
            //BBS: notify instance updates to part plater list
            m_selection.notify_instance_update(i.first, i.second);
        }
        wxGetApp().obj_list()->update_info_items(static_cast<size_t>(i.first));
 
        //BBS: notify instance updates to part plater list
        PartPlateList &plate_list = wxGetApp().plater()->get_partplate_list();
        plate_list.notify_instance_update(i.first, i.second);
    }    
    
    //BBS: nofity object list to update
    wxGetApp().plater()->sidebar().obj_list()->update_plate_values_for_items();
 
    post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
 
    // IMEX: mirror changes per-instance transforms without touching the ghost cache key.
    wxGetApp().plater()->get_partplate_list().invalidate_all_imex_ghosts();
 
    m_dirty = true;
}

References Slic3r::ModelObject::auto_drop, Slic3r::ModelObject::get_instance_min_z(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::GUI::Selection::Instance, Slic3r::ModelObject::instance_bounding_box(), Slic3r::GLVolume::instance_idx(), Slic3r::ModelObject::instances, Slic3r::ModelObject::invalidate_bounding_box(), m_dirty, m_model, m_selection, m_volumes, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::GUI::PartPlateList::notify_instance_update(), Slic3r::GLVolume::object_idx(), post_event(), Slic3r::save_object_mesh(), Slic3r::SINKING_Z_THRESHOLD, Slic3r::ModelObject::translate_instance(), Slic3r::GUI::Selection::Volume, Slic3r::GLVolume::volume_idx(), and Slic3r::ModelObject::volumes.

Referenced by mirror_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_move()

void Slic3r::GUI::GLCanvas3D::do_move	(	const std::string &	snapshot_type,
		bool	force_volume_move = false )

{
    if (m_model == nullptr)
        return;
 
    if (!snapshot_type.empty())
        wxGetApp().plater()->take_snapshot(snapshot_type);
 
    std::set<std::pair<int, int>> done;  // keeps track of modified instances
    bool object_moved = false;
 
    // BBS: support wipe-tower for multi-plates
    int n_plates = wxGetApp().plater()->get_partplate_list().get_plate_count();
    std::vector<Vec3d> wipe_tower_origins(n_plates, Vec3d::Zero());
 
    Selection::EMode selection_mode = m_selection.get_mode();
 
    for (const GLVolume* v : m_volumes.volumes) {
        int object_idx = v->object_idx();
        int instance_idx = v->instance_idx();
        int volume_idx = v->volume_idx();
 
        if (volume_idx < 0)
            continue;
 
        std::pair<int, int> done_id(object_idx, instance_idx);
 
        if (0 <= object_idx && object_idx < (int)m_model->objects.size()) {
            done.insert(done_id);
 
            // Move instances/volumes
            ModelObject* model_object = m_model->objects[object_idx];
            if (model_object == nullptr)
                continue;
 
            if (force_volume_move || selection_mode == Selection::Volume) {
                auto cur_mv = model_object->volumes[volume_idx];
                if (cur_mv->get_transformation() != v->get_volume_transformation()) {
                    cur_mv->set_transformation(v->get_volume_transformation());
                    // BBS: backup
                    Slic3r::save_object_mesh(*model_object);
                }
            }
            else if (selection_mode == Selection::Instance) {
                if (m_canvas_type == GLCanvas3D::ECanvasType::CanvasAssembleView) {
                    if ((model_object->instances[instance_idx]->get_assemble_offset() - v->get_instance_offset()).norm() > 1e-2) {
                        model_object->instances[instance_idx]->set_assemble_transformation(v->get_instance_transformation());
                    }
                } else {
                    model_object->instances[instance_idx]->set_transformation(v->get_instance_transformation());
                }
            }
 
            object_moved = true;
            model_object->invalidate_bounding_box();
            
        }
        else if (object_idx >= 1000 && object_idx < 1000 + n_plates) {
            // Move a wipe tower proxy.
            wipe_tower_origins[object_idx - 1000] = v->get_volume_offset();
        }
    }
 
    //BBS: notify instance updates to part plater list
    // Only what moved: the selected instances, or every instance of an object one of whose
    // parts moved. Notifying a plate about an instance that stayed put invalidates its slice
    // result, and notifying instance 0 alone left a moved copy unregistered on its new plate.
    {
        const bool parts_moved = force_volume_move || selection_mode == Selection::Volume;
        std::set<std::pair<int, int>> notified;
        for (unsigned int i : m_selection.get_volume_idxs()) {
            const GLVolume* v          = m_volumes.volumes[i];
            const int       object_idx = v->object_idx();
            if (object_idx < 0 || object_idx >= static_cast<int>(m_model->objects.size()))
                continue;
            const std::pair<int, int> key(object_idx, parts_moved ? -1 : v->instance_idx());
            if (notified.insert(key).second)
                m_selection.notify_instance_update(key.first, key.second);
        }
    }
 
    // Fixes sinking/flying instances (snaps object to buildplate)
    for (const std::pair<int, int>& i : done) {
        ModelObject* mo = m_model->objects[i.first];
 
        const double shift_z = mo->get_instance_min_z(i.second);
        //BBS: don't call translate if the z is zero
        if (mo->auto_drop && (current_printer_technology() == ptSLA || shift_z > SINKING_Z_THRESHOLD) && (shift_z != 0.0f)) {
            const Vec3d shift(0.0, 0.0, -shift_z);
            m_selection.translate(i.first, i.second, shift);
            mo->translate_instance(i.second, shift);
            //BBS: notify instance updates to part plater list
            m_selection.notify_instance_update(i.first, i.second);
        }
        wxGetApp().obj_list()->update_info_items(static_cast<size_t>(i.first));
    }
    
    //BBS: nofity object list to update
    wxGetApp().plater()->sidebar().obj_list()->update_plate_values_for_items();
 
    if (object_moved) {
        Slic3r::LifecycleEventContext ctx;
        ctx.code = Slic3r::LifecycleEvtCode::Ok;
        ctx.msg = "moved";
        if (done.size() == 1)
            ctx.name = m_model->objects[done.begin()->first]->name;
        Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::ObjectTransformed, ctx);
 
        post_event(SimpleEvent(EVT_GLCANVAS_INSTANCE_MOVED));
    }
 
    // BBS: support wipe-tower for multi-plates
    for (int plate_id = 0; plate_id < wipe_tower_origins.size(); plate_id++) {
        Vec3d& wipe_tower_origin = wipe_tower_origins[plate_id];
        if (wipe_tower_origin == Vec3d::Zero())
            continue;
 
        PartPlateList& ppl = wxGetApp().plater()->get_partplate_list();
        DynamicConfig& proj_cfg = wxGetApp().preset_bundle->project_config;
        Vec3d plate_origin = ppl.get_plate(plate_id)->get_origin();
        ConfigOptionFloat wipe_tower_x(wipe_tower_origin(0) - plate_origin(0));
        ConfigOptionFloat wipe_tower_y(wipe_tower_origin(1) - plate_origin(1));
 
        ConfigOptionFloats* wipe_tower_x_opt = proj_cfg.option<ConfigOptionFloats>("wipe_tower_x", true);
        ConfigOptionFloats* wipe_tower_y_opt = proj_cfg.option<ConfigOptionFloats>("wipe_tower_y", true);
        wipe_tower_x_opt->set_at(&wipe_tower_x, plate_id, 0);
        wipe_tower_y_opt->set_at(&wipe_tower_y, plate_id, 0);
    }
 
    reset_sequential_print_clearance();
 
    // IMEX: selection commit may have moved/added/removed objects — ghost cache key
    // doesn't encode per-instance transforms, so force a full rebuild on next render.
    wxGetApp().plater()->get_partplate_list().invalidate_all_imex_ghosts();
 
    m_dirty = true;
}

References Slic3r::ModelObject::auto_drop, CanvasAssembleView, Slic3r::LifecycleEventContext::code, current_printer_technology(), Slic3r::fire_lifecycle_event(), Slic3r::ModelObject::get_instance_min_z(), Slic3r::GLVolume::get_instance_offset(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::GUI::PartPlate::get_origin(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GLVolume::get_volume_offset(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::GUI::Selection::Instance, Slic3r::GLVolume::instance_idx(), Slic3r::ModelObject::instances, Slic3r::ModelObject::invalidate_bounding_box(), m_canvas_type, m_dirty, m_model, m_selection, m_volumes, Slic3r::LifecycleEventContext::msg, Slic3r::LifecycleEventContext::name, Slic3r::GLVolume::object_idx(), Slic3r::ObjectTransformed, Slic3r::Ok, Slic3r::ConfigBase::option(), post_event(), Slic3r::ptSLA, reset_sequential_print_clearance(), Slic3r::save_object_mesh(), Slic3r::ConfigOptionVector< double >::set_at(), Slic3r::SINKING_Z_THRESHOLD, Slic3r::ModelObject::translate_instance(), Slic3r::GUI::Selection::Volume, Slic3r::GLVolume::volume_idx(), Slic3r::ModelObject::volumes, and Slic3r::wipe_tower_y().

Referenced by finish_selection_edit(), anonymous_namespace{GLGizmoEmboss.cpp}::fix_transformation(), on_mouse(), and Slic3r::GUI::on_mouse_surface_drag().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_rotate()

void Slic3r::GUI::GLCanvas3D::do_rotate ( const std::string & snapshot_type )

{
    if (m_model == nullptr)
        return;
 
    if (!snapshot_type.empty())
        wxGetApp().plater()->take_snapshot(snapshot_type);
 
    // stores current min_z of instances
    std::map<std::pair<int, int>, double> min_zs;
    for (int i = 0; i < static_cast<int>(m_model->objects.size()); ++i) {
        const ModelObject* obj = m_model->objects[i];
        for (int j = 0; j < static_cast<int>(obj->instances.size()); ++j) {
            if (snapshot_type == L("Gizmo-Place on Face") && m_selection.get_object_idx() == i) {
                // This means we are flattening this object. In that case pretend
                // that it is not sinking (even if it is), so it is placed on bed
                // later on (whatever is sinking will be left sinking).
                min_zs[{ i, j }] = SINKING_Z_THRESHOLD;
            }
            else
                min_zs[{ i, j }] = obj->instance_bounding_box(j).min.z();
 
        }
    }
 
    std::set<std::pair<int, int>> done;  // keeps track of modified instances
 
    Selection::EMode selection_mode = m_selection.get_mode();
 
    for (const GLVolume* v : m_volumes.volumes) {
        const int object_idx = v->object_idx();
        if (object_idx < 0 || (int)m_model->objects.size() <= object_idx)
            continue;
 
        const int instance_idx = v->instance_idx();
        const int volume_idx = v->volume_idx();
 
        if (volume_idx < 0)
            continue;
 
        done.insert(std::pair<int, int>(object_idx, instance_idx));
 
        // Rotate instances/volumes.
        ModelObject* model_object = m_model->objects[object_idx];
        if (model_object == nullptr)
            continue;
 
        if (selection_mode == Selection::Instance) {
            if (m_canvas_type == GLCanvas3D::ECanvasType::CanvasAssembleView) {
                model_object->instances[instance_idx]->set_assemble_from_transform(v->get_instance_transformation().get_matrix());
            } else {
                model_object->instances[instance_idx]->set_transformation(v->get_instance_transformation());
            }
        }
        else if (selection_mode == Selection::Volume) {
            auto cur_mv = model_object->volumes[volume_idx];
            if (cur_mv->get_transformation() != v->get_volume_transformation()) {
                cur_mv->set_transformation(v->get_volume_transformation());
                // BBS: backup
                Slic3r::save_object_mesh(*model_object);
            }
        }
        model_object->invalidate_bounding_box();
    }
 
    //BBS: notify instance updates to part plater list
    m_selection.notify_instance_update(-1, -1);
 
    if (m_canvas_type != CanvasAssembleView) {
        // Fixes sinking/flying instances (snaps object to buildplate)
        for (const std::pair<int, int> &i : done) {
            ModelObject *mo = m_model->objects[i.first];
 
            // BBS: don't call translate if the z is zero
            const double shift_z = mo->get_instance_min_z(i.second);
            // leave sinking instances as sinking
            if (mo->auto_drop && (min_zs.find({i.first, i.second})->second >= SINKING_Z_THRESHOLD || shift_z > SINKING_Z_THRESHOLD) && (shift_z != 0.0f)) {
                const Vec3d shift(0.0, 0.0, -shift_z);
                m_selection.translate(i.first, i.second, shift);
                mo->translate_instance(i.second, shift);
                // BBS: notify instance updates to part plater list
                m_selection.notify_instance_update(i.first, i.second);
            }
 
            wxGetApp().obj_list()->update_info_items(static_cast<size_t>(i.first));
        }
    }
 
    //BBS: nofity object list to update
    wxGetApp().plater()->sidebar().obj_list()->update_plate_values_for_items();
 
    if (!done.empty()) {
        Slic3r::LifecycleEventContext ctx;
        ctx.code = Slic3r::LifecycleEvtCode::Ok;
        ctx.msg = "rotated";
        if (done.size() == 1)
            ctx.name = m_model->objects[done.begin()->first]->name;
        Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::ObjectTransformed, ctx);
 
        post_event(SimpleEvent(EVT_GLCANVAS_INSTANCE_ROTATED));
    }
 
    // IMEX: rotate changes per-instance transforms without touching the ghost cache key.
    wxGetApp().plater()->get_partplate_list().invalidate_all_imex_ghosts();
 
    m_dirty = true;
}

References Slic3r::ModelObject::auto_drop, CanvasAssembleView, Slic3r::LifecycleEventContext::code, Slic3r::fire_lifecycle_event(), Slic3r::ModelObject::get_instance_min_z(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::GUI::Selection::Instance, Slic3r::ModelObject::instance_bounding_box(), Slic3r::GLVolume::instance_idx(), Slic3r::ModelObject::instances, Slic3r::ModelObject::invalidate_bounding_box(), L, m_canvas_type, m_dirty, m_model, m_selection, m_volumes, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::LifecycleEventContext::msg, Slic3r::LifecycleEventContext::name, Slic3r::GLVolume::object_idx(), Slic3r::ObjectTransformed, Slic3r::Ok, post_event(), Slic3r::save_object_mesh(), Slic3r::SINKING_Z_THRESHOLD, Slic3r::ModelObject::translate_instance(), Slic3r::GUI::Selection::Volume, Slic3r::GLVolume::volume_idx(), and Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::face_selected_volume_to_camera(), finish_selection_edit(), and anonymous_namespace{GLGizmoEmboss.cpp}::fix_transformation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_scale()

void Slic3r::GUI::GLCanvas3D::do_scale ( const std::string & snapshot_type )

{
    if (m_model == nullptr)
        return;
 
    if (!snapshot_type.empty())
        wxGetApp().plater()->take_snapshot(snapshot_type);
 
    // stores current min_z of instances
    std::map<std::pair<int, int>, double> min_zs;
    if (!snapshot_type.empty()) {
        for (int i = 0; i < static_cast<int>(m_model->objects.size()); ++i) {
            const ModelObject* obj = m_model->objects[i];
            for (int j = 0; j < static_cast<int>(obj->instances.size()); ++j) {
                min_zs[{ i, j }] = obj->instance_bounding_box(j).min.z();
            }
        }
    }
 
    std::set<std::pair<int, int>> done;  // keeps track of modified instances
 
    Selection::EMode selection_mode = m_selection.get_mode();
 
    for (const GLVolume* v : m_volumes.volumes) {
        const int object_idx = v->object_idx();
        if (object_idx < 0 || (int)m_model->objects.size() <= object_idx)
            continue;
 
        const int instance_idx = v->instance_idx();
        const int volume_idx = v->volume_idx();
 
        if (volume_idx < 0)
            continue;
 
        done.insert(std::pair<int, int>(object_idx, instance_idx));
 
        // Rotate instances/volumes
        ModelObject* model_object = m_model->objects[object_idx];
        if (model_object == nullptr)
            continue;
 
        if (selection_mode == Selection::Instance) {
            model_object->instances[instance_idx]->set_transformation(v->get_instance_transformation());
        }
        else if (selection_mode == Selection::Volume) {
            auto cur_mv = model_object->volumes[volume_idx];
            if (cur_mv->get_transformation() != v->get_volume_transformation()) {
                model_object->instances[instance_idx]->set_transformation(v->get_instance_transformation());
                cur_mv->set_transformation(v->get_volume_transformation());
                // BBS: backup
                Slic3r::save_object_mesh(*model_object);
            }
        }
        model_object->invalidate_bounding_box();
    }
 
    //BBS: notify instance updates to part plater list
    m_selection.notify_instance_update(-1, -1);
 
    // Fixes sinking/flying instances (snaps object to buildplate)
    for (const std::pair<int, int>& i : done) {
        ModelObject* mo = m_model->objects[i.first];
 
        //BBS: don't call translate if the z is zero
        double shift_z = mo->get_instance_min_z(i.second);
        // leave sinking instances as sinking
        if (mo->auto_drop && (min_zs.empty() || min_zs.find({ i.first, i.second })->second >= SINKING_Z_THRESHOLD || shift_z > SINKING_Z_THRESHOLD) && (shift_z != 0.0f)) {
            Vec3d shift(0.0, 0.0, -shift_z);
            m_selection.translate(i.first, i.second, shift);
            mo->translate_instance(i.second, shift);
            //BBS: notify instance updates to part plater list
            m_selection.notify_instance_update(i.first, i.second);
        }
        wxGetApp().obj_list()->update_info_items(static_cast<size_t>(i.first));
    }
    
    //BBS: nofity object list to update
    wxGetApp().plater()->sidebar().obj_list()->update_plate_values_for_items();
    //BBS: notify object info update
    wxGetApp().plater()->show_object_info();
 
    if (!done.empty()) {
        Slic3r::LifecycleEventContext ctx;
        ctx.code = Slic3r::LifecycleEvtCode::Ok;
        ctx.msg = "scaled";
        if (done.size() == 1)
            ctx.name = m_model->objects[done.begin()->first]->name;
        Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::ObjectTransformed, ctx);
 
        post_event(SimpleEvent(EVT_GLCANVAS_INSTANCE_SCALED));
    }
 
    // IMEX: scale changes per-instance transforms without touching the ghost cache key.
    wxGetApp().plater()->get_partplate_list().invalidate_all_imex_ghosts();
 
    m_dirty = true;
}

References Slic3r::ModelObject::auto_drop, Slic3r::LifecycleEventContext::code, Slic3r::fire_lifecycle_event(), Slic3r::ModelObject::get_instance_min_z(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::GUI::Selection::Instance, Slic3r::ModelObject::instance_bounding_box(), Slic3r::GLVolume::instance_idx(), Slic3r::ModelObject::instances, Slic3r::ModelObject::invalidate_bounding_box(), m_dirty, m_model, m_selection, m_volumes, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::LifecycleEventContext::msg, Slic3r::LifecycleEventContext::name, Slic3r::GLVolume::object_idx(), Slic3r::ObjectTransformed, Slic3r::Ok, post_event(), Slic3r::save_object_mesh(), Slic3r::SINKING_Z_THRESHOLD, Slic3r::ModelObject::translate_instance(), Slic3r::GUI::Selection::Volume, Slic3r::GLVolume::volume_idx(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

◆ enable_assemble_view_toolbar()

void Slic3r::GUI::GLCanvas3D::enable_assemble_view_toolbar ( bool enable )

{
    m_assemble_view_toolbar.set_enabled(enable);
}

References m_assemble_view_toolbar.

◆ enable_collapse_toolbar()

void Slic3r::GUI::GLCanvas3D::enable_collapse_toolbar ( bool enable )

{
    m_collapse_toolbar_enabled = enable;
}

References m_collapse_toolbar_enabled.

◆ enable_dynamic_background()

void Slic3r::GUI::GLCanvas3D::enable_dynamic_background ( bool enable )

inline

1121{ m_dynamic_background_enabled = enable; }

References m_dynamic_background_enabled.

◆ enable_gizmos()

void Slic3r::GUI::GLCanvas3D::enable_gizmos ( bool enable )

inline

1095{ m_gizmos.set_enabled(enable); }

References m_gizmos.

◆ enable_labels()

void Slic3r::GUI::GLCanvas3D::enable_labels ( bool enable )

inline

1122{ m_labels.enable(enable); }

References m_labels.

◆ enable_layers_editing()

void Slic3r::GUI::GLCanvas3D::enable_layers_editing ( bool enable )

{
    m_layers_editing.set_enabled(enable);
    set_as_dirty();
}

References m_layers_editing, and set_as_dirty().

Here is the call graph for this function:

◆ enable_main_toolbar()

void Slic3r::GUI::GLCanvas3D::enable_main_toolbar ( bool enable )

inline

1097{ m_main_toolbar.set_enabled(enable); }

References m_main_toolbar.

◆ enable_moving()

void Slic3r::GUI::GLCanvas3D::enable_moving ( bool enable )

inline

1094{ m_moving_enabled = enable; }

References m_moving_enabled.

Referenced by Slic3r::GUI::on_mouse_surface_drag(), and anonymous_namespace{SurfaceDrag.cpp}::start_dragging().

Here is the caller graph for this function:

◆ enable_picking()

void Slic3r::GUI::GLCanvas3D::enable_picking ( bool enable )

inline

    {
        m_picking_enabled = enable;
        // Orca: invalidate hover state when dragging is toggled, otherwise if we turned off dragging
        // while hovering above a volume, the hovering state won't update even if mouse has moved away.
        // Fixes https://github.com/OrcaSlicer/OrcaSlicer/pull/9979#issuecomment-3065575889
        m_hover_volume_idxs.clear();
    }

References m_hover_volume_idxs, and m_picking_enabled.

Referenced by Slic3r::GUI::on_mouse_surface_drag(), and anonymous_namespace{SurfaceDrag.cpp}::start_dragging().

Here is the caller graph for this function:

◆ enable_plate_chrome()

void Slic3r::GUI::GLCanvas3D::enable_plate_chrome ( bool enable )

{
    m_plate_chrome_enabled = enable;
}

References m_plate_chrome_enabled.

◆ enable_render()

void Slic3r::GUI::GLCanvas3D::enable_render ( bool enabled )

inline

    {
        m_enable_render = enabled;
    }

References m_enable_render.

◆ enable_return_toolbar()

void Slic3r::GUI::GLCanvas3D::enable_return_toolbar ( bool enable )

{
    m_return_toolbar.set_enabled(enable);
}

References m_return_toolbar.

Referenced by _render_frame().

Here is the caller graph for this function:

◆ enable_select_plate_toolbar()

void Slic3r::GUI::GLCanvas3D::enable_select_plate_toolbar ( bool enable )

{
    m_sel_plate_toolbar.set_enabled(enable);
}

References m_sel_plate_toolbar.

◆ enable_selection()

void Slic3r::GUI::GLCanvas3D::enable_selection ( bool enable )

inline

1096{ m_selection.set_enabled(enable); }

References m_selection.

◆ enable_separator_toolbar()

void Slic3r::GUI::GLCanvas3D::enable_separator_toolbar ( bool enable )

{
    m_separator_toolbar.set_enabled(enable);
}

References m_separator_toolbar.

◆ enable_sinking_contours()

void Slic3r::GUI::GLCanvas3D::enable_sinking_contours ( bool enable )

inline

1114{ m_sinking_contours_enabled = enable; }

References m_sinking_contours_enabled.

◆ enable_slope()

void Slic3r::GUI::GLCanvas3D::enable_slope ( bool enable )

inline

1123{ m_slope.enable(enable); }

References m_slope.

◆ ensure_on_bed()

void Slic3r::GUI::GLCanvas3D::ensure_on_bed	(	unsigned int	object_idx,
		bool	allow_negative_z )

{
    //BBS if asseble view canvas
    if (m_canvas_type == ECanvasType::CanvasAssembleView) {
        return;
    }
 
    if (allow_negative_z)
        return;
 
    typedef std::map<std::pair<int, int>, double> InstancesToZMap;
    InstancesToZMap instances_min_z;
 
    for (GLVolume* volume : m_volumes.volumes) {
        ModelObject* mo = m_model->objects[volume->object_idx()];
 
        if (!mo->auto_drop) {
            continue;
        }
 
        if (volume->object_idx() == (int)object_idx && !volume->is_modifier) {
            double min_z = volume->transformed_convex_hull_bounding_box().min.z();
            std::pair<int, int> instance = std::make_pair(volume->object_idx(), volume->instance_idx());
            InstancesToZMap::iterator it = instances_min_z.find(instance);
            if (it == instances_min_z.end())
                it = instances_min_z.insert(InstancesToZMap::value_type(instance, DBL_MAX)).first;
 
            it->second = std::min(it->second, min_z);
        }
    }
 
    for (GLVolume* volume : m_volumes.volumes) {
        std::pair<int, int> instance = std::make_pair(volume->object_idx(), volume->instance_idx());
        InstancesToZMap::iterator it = instances_min_z.find(instance);
        if (it != instances_min_z.end())
            volume->set_instance_offset(Z, volume->get_instance_offset(Z) - it->second);
    }
}

References Slic3r::ModelObject::auto_drop, CanvasAssembleView, Slic3r::GLVolume::get_instance_offset(), Slic3r::GLVolume::instance_idx(), m_canvas_type, m_model, m_volumes, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::GLVolume::object_idx(), Slic3r::GLVolume::set_instance_offset(), Slic3r::GLVolume::transformed_convex_hull_bounding_box(), and Slic3r::Z.

Here is the call graph for this function:

◆ exit_gizmo()

void Slic3r::GUI::GLCanvas3D::exit_gizmo ( )

                            {
    if (m_gizmos.get_current_type() != GLGizmosManager::Undefined) {
        m_gizmos.reset_all_states();
        m_gizmos.update_data();
    }
}

References m_gizmos, and Slic3r::GUI::GLGizmosManager::Undefined.

◆ export_toolpaths_to_obj()

void Slic3r::GUI::GLCanvas3D::export_toolpaths_to_obj ( const char * filename ) const

inline

1398{ m_gcode_viewer.export_toolpaths_to_obj(filename); }

References m_gcode_viewer.

◆ fff_print()

const Print * Slic3r::GUI::GLCanvas3D::fff_print ( ) const

{
    return (m_process == nullptr) ? nullptr : m_process->fff_print();
}

References fff_print(), and m_process.

Referenced by _max_bounding_box(), _render_overlays(), fff_print(), load_gcode_preview(), on_mouse(), set_config(), update_compacted_wipe_tower_clearance(), and update_sequential_clearance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finish_selection_edit()

void Slic3r::GUI::GLCanvas3D::finish_selection_edit ( )

{
    const SelectionEdit::Kind kind = m_selection_edit.kind;
    m_selection_edit.kind          = SelectionEdit::None;
    if (kind == SelectionEdit::Move)
        do_move(L("Tool move"));
    else
        do_rotate(L("Tool Rotate"));
    m_gizmos.update_data();
    // Let the plater know that the dragging finished, so a delayed refresh
    // of the scene with the background processing data should be performed.
    post_event(SimpleEvent(EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED));
    // updates camera target constraints
    refresh_camera_scene_box();
    m_dirty = true;
}

References do_move(), do_rotate(), L, m_dirty, m_gizmos, m_selection_edit, Slic3r::GUI::GLCanvas3D::SelectionEdit::Move, Slic3r::GUI::GLCanvas3D::SelectionEdit::None, post_event(), and refresh_camera_scene_box().

Referenced by bind_event_handlers(), and on_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ force_main_toolbar_left_action()

void Slic3r::GUI::GLCanvas3D::force_main_toolbar_left_action ( int item_id )

inline

1394{ m_main_toolbar.force_left_action(item_id, *this); }

References m_main_toolbar.

Referenced by _init_main_toolbar().

Here is the caller graph for this function:

◆ force_main_toolbar_right_action()

void Slic3r::GUI::GLCanvas3D::force_main_toolbar_right_action ( int item_id )

inline

1395{ m_main_toolbar.force_right_action(item_id, *this); }

References m_main_toolbar.

◆ force_set_focus()

void Slic3r::GUI::GLCanvas3D::force_set_focus ( )

                                 {
    m_canvas->SetFocus();
};

References m_canvas.

Referenced by Slic3r::GUI::MainFrame::handle_global_shortcut(), and Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the caller graph for this function:

◆ get_arrange_settings()

GLCanvas3D::ArrangeSettings & Slic3r::GUI::GLCanvas3D::get_arrange_settings ( )

{
    PrinterTechnology ptech = current_printer_technology();
 
    auto* ptr = &m_arrange_settings_fff;
 
    if (ptech == ptSLA) {
        ptr = &m_arrange_settings_sla;
    }
    else if (ptech == ptFFF) {
        if (wxGetApp().global_print_sequence() == PrintSequence::ByObject)
            ptr = &m_arrange_settings_fff_seq_print;
        else
            ptr = &m_arrange_settings_fff;
    }
 
    return *ptr;
}

References Slic3r::ByObject, current_printer_technology(), get_arrange_settings(), m_arrange_settings_fff, m_arrange_settings_fff_seq_print, m_arrange_settings_sla, Slic3r::ptFFF, and Slic3r::ptSLA.

Referenced by _render_arrange_menu(), get_arrange_settings(), and Slic3r::GUI::init_arrange_params().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_assemble_view_toolbar_height()

float Slic3r::GUI::GLCanvas3D::get_assemble_view_toolbar_height ( ) const

inline

1140{ return m_assemble_view_toolbar.get_height(); }

References m_assemble_view_toolbar.

◆ get_assemble_view_toolbar_width()

float Slic3r::GUI::GLCanvas3D::get_assemble_view_toolbar_width ( ) const

inline

1139{ return m_assemble_view_toolbar.get_width(); }

References m_assemble_view_toolbar.

◆ get_assembly_paint_toolbar_width()

float Slic3r::GUI::GLCanvas3D::get_assembly_paint_toolbar_width ( ) const

inline

1141{ return m_paint_toolbar_width; }

References m_paint_toolbar_width.

◆ get_camera()

Camera & Slic3r::GUI::GLCanvas3D::get_camera ( )

{
    return camera;
}

References camera.

Referenced by _mouse_to_3d(), _picking_pass(), _render_arrange_menu(), _render_orient_menu(), on_idle(), and Slic3r::GUI::GLCanvas3D::CenterOfMass::render_details().

Here is the caller graph for this function:

◆ get_camera_orbit_target()

std::optional< Vec3d > Slic3r::GUI::GLCanvas3D::get_camera_orbit_target ( ECameraNavigationType navigation_type ) const

private

{
    // Orca: Centralize the pre-existing pivot rules so orbiting and pan fallback cannot
    // choose different reference depths for the same canvas and active tool.
    const BoundingBoxf3 plate_box = _current_plate_box();
    if (navigation_type == ECameraNavigationType::Gesture)
        return plate_box.defined ? std::make_optional(plate_box.center()) : std::nullopt;
 
    const GLGizmosManager::EType gizmo_type = m_gizmos.get_current_type();
    const bool use_scene_target = m_canvas_type == ECanvasType::CanvasAssembleView ||
        gizmo_type == GLGizmosManager::FdmSupports || gizmo_type == GLGizmosManager::Seam ||
        gizmo_type == GLGizmosManager::MmSegmentation || gizmo_type == GLGizmosManager::FuzzySkin;
    if (use_scene_target) {
        if (!m_selection.is_empty())
            return m_selection.get_bounding_box().center();
 
        // Orca: Preserve the world-origin fallback used by orbit in an empty scene.
        return volumes_bounding_box().center();
    }
 
    // Orca: Free-camera rotation uses Camera::m_target rather than a plate or selection pivot.
    if (wxGetApp().app_config->get_bool("use_free_camera"))
        return std::nullopt;
 
    Vec3d target = Vec3d::Zero();
    if (m_canvas_type == ECanvasType::CanvasPreview) {
        if (plate_box.defined)
            target = plate_box.center();
    } else if (!m_selection.is_empty()) {
        target = m_selection.get_bounding_box().center();
    } else {
        // Orca: Match regular mouse orbit: objects on the active plate, then the plate itself.
        BoundingBoxf3 bbox = volumes_bounding_box(true);
        if (!bbox.defined)
            bbox = plate_box;
        if (bbox.defined)
            target = bbox.center();
    }
 
    // Orca: Preserve the existing zero sentinel used by regular mouse orbit.
    return target.isZero() ? std::nullopt : std::make_optional(target);
}

References _current_plate_box(), CanvasAssembleView, CanvasPreview, Slic3r::BoundingBox3Base< PointType >::center(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::defined, Slic3r::GUI::GLGizmosManager::FdmSupports, Slic3r::GUI::GLGizmosManager::FuzzySkin, Gesture, get_camera_orbit_target(), m_canvas_type, m_gizmos, m_selection, Slic3r::GUI::GLGizmosManager::MmSegmentation, Slic3r::GUI::GLGizmosManager::Seam, and volumes_bounding_box().

Referenced by get_camera_orbit_target(), get_camera_pan_anchor(), on_gesture(), and on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_camera_pan_anchor()

Vec3d Slic3r::GUI::GLCanvas3D::get_camera_pan_anchor	(	Camera &	camera,
		ECameraNavigationType	navigation_type,
		const Vec2d &	screen_position ) const

private

{
    // Orthographic panning has the same scale at every depth, so no raycast is needed.
    if (camera.get_type() != Camera::EType::Perspective)
        return camera.get_target();
 
    // Orca: Reject non-finite anchors and points behind the camera before their depth is
    // allowed to scale a perspective pan.
    const Vec3d camera_position = camera.get_position();
    const Vec3d camera_forward = camera.get_dir_forward();
    const auto is_valid_anchor = [&camera_position, &camera_forward](const Vec3d& anchor) {
        return anchor.allFinite() && (anchor - camera_position).dot(camera_forward) > EPSILON;
    };
 
    // Orca: Prefer the nearest visible bed or volume surface and exclude gizmos and
    // selected-volume picking priority from navigation depth selection.
    const ClippingPlane clipping_plane = get_raycaster_clipping_plane();
    const bool bed_visible = is_bed_visible();
    const SceneRaycaster::HitResult hit = m_scene_raycaster.hit(screen_position, camera, &clipping_plane,
        bed_visible ? SceneRaycaster::EHitMode::SceneOnly : SceneRaycaster::EHitMode::VolumesOnly);
    if (hit.is_valid()) {
        const Vec3d hit_position = hit.position.cast<double>();
        if (is_valid_anchor(hit_position))
            return hit_position;
    }
 
    // Orca: When the cursor is just outside the visible plate, use the point under it on the active
    // plate plane. Using the plate center here would give it a different perspective depth.
    PartPlate* current_plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
    // Orca: An almost edge-on perspective makes intersection depth extremely sensitive to
    // the cursor's vertical position. Use the stable orbit depth around horizontal views.
    static constexpr double min_plate_plane_forward_z = 0.05;
    if (bed_visible && std::abs(camera_forward.z()) >= min_plate_plane_forward_z &&
        current_plate != nullptr && current_plate->get_bounding_box().defined) {
        Vec3d ray_origin;
        Vec3d ray_direction;
        CameraUtils::ray_from_screen_pos(camera, screen_position, ray_origin, ray_direction);
        const double z_direction = ray_direction.z();
        if (ray_origin.allFinite() && ray_direction.allFinite() && std::abs(z_direction) > EPSILON) {
            const double plate_z = current_plate->get_bounding_box().center().z();
            const double distance = (plate_z - ray_origin.z()) / z_direction;
            const Vec3d plate_position = ray_origin + distance * ray_direction;
            const double eye_depth = (plate_position - camera_position).dot(camera_forward);
            if (distance >= 0.0 && is_valid_anchor(plate_position) &&
                eye_depth >= camera.get_near_z() && eye_depth <= camera.get_far_z())
                return plate_position;
        }
    }
 
    // Orca: Near-horizontal rays and points outside the scene depth use the orbit reference point.
    const std::optional<Vec3d> orbit_target = get_camera_orbit_target(navigation_type);
    return orbit_target.has_value() && is_valid_anchor(*orbit_target) ? *orbit_target : camera.get_target();
}

References camera, Slic3r::BoundingBox3Base< PointType >::center(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::defined, Slic3r::dot(), EPSILON, Slic3r::GUI::PartPlate::get_bounding_box(), get_camera_orbit_target(), get_camera_pan_anchor(), get_raycaster_clipping_plane(), is_bed_visible(), Slic3r::GUI::SceneRaycaster::HitResult::is_valid(), m_scene_raycaster, Slic3r::GUI::Camera::Perspective, Slic3r::GUI::SceneRaycaster::HitResult::position, Slic3r::GUI::CameraUtils::ray_from_screen_pos(), Slic3r::GUI::SceneRaycaster::SceneOnly, and Slic3r::GUI::SceneRaycaster::VolumesOnly.

Referenced by get_camera_pan_anchor(), on_gesture(), and on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_canvas_size()

Size Slic3r::GUI::GLCanvas3D::get_canvas_size ( ) const

{
    int w = 0;
    int h = 0;
 
    if (m_canvas != nullptr)
        m_canvas->GetSize(&w, &h);
 
#if ENABLE_RETINA_GL
    const float factor = m_retina_helper->get_scale_factor();
    w *= factor;
    h *= factor;
#else
    const float factor = 1.0f;
#endif
 
    return Size(w, h, factor);
}

References m_canvas.

Referenced by _check_and_update_toolbar_icon_scale(), _picking_pass(), _rectangular_selection_picking_pass(), _refresh_if_shown_on_screen(), _render_arrange_menu(), _render_assemble_control(), _render_assemble_info(), _render_assemble_view_toolbar(), _render_canvas_toolbar(), _render_collapse_toolbar(), _render_frame(), _render_imgui_select_plate_toolbar(), _render_main_toolbar(), _render_objects(), _render_orient_menu(), _render_paint_toolbar(), _render_plate_switcher(), _render_return_toolbar(), _render_separator_toolbar_left(), _render_separator_toolbar_right(), _render_wireframe_overlay(), _render_xray_volumes(), Slic3r::GUI::NotificationManager::PopNotification::bbl_render_block_notification(), Slic3r::GUI::MainFrame::GLResourcesPrebuild::build_step(), Slic3r::GUI::GLToolbar::contains_mouse_horizontal(), Slic3r::GUI::GLToolbar::contains_mouse_vertical(), Slic3r::GUI::GLCanvas3D::LayersEditing::get_bar_rect_screen(), get_main_toolbar_offset(), on_mouse(), on_mouse_wheel(), Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::on_timer(), Slic3r::GUI::GLCanvas3D::Tooltip::render(), Slic3r::GUI::GLSelectionRectangle::render(), Slic3r::GUI::NotificationManager::PopNotification::render(), Slic3r::GUI::NotificationManager::SlicingProgressNotification::render(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_active_object_annotations(), Slic3r::GUI::GLToolbar::render_horizontal(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_profile(), Slic3r::GUI::Mouse3DController::render_settings_dialog(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_variable_layer_height_dialog(), Slic3r::GUI::GLToolbar::render_vertical(), Slic3r::GUI::Emboss::start_create_volume_without_position(), Slic3r::GUI::GLCanvas3D::LayersEditing::thickness_bar_width(), Slic3r::GUI::GLToolbar::update_hover_state_horizontal(), and Slic3r::GUI::GLToolbar::update_hover_state_vertical().

Here is the caller graph for this function:

◆ get_canvas_toolbar_right()

float Slic3r::GUI::GLCanvas3D::get_canvas_toolbar_right ( ) const

{
    // The toolbar scale, which on Windows follows the monitor's DPI where the ImGui style does not.
    float sc = get_scale();
#ifdef WIN32
    sc *= (float) get_dpi_for_window(wxGetApp().GetTopWindow()) / (float) DPI_DEFAULT;
#endif // WIN32
    const float left = wxGetApp().show_3d_navigator() ? NAVIGATOR_SIZE : CANVAS_TOOLBAR_MARGIN;
    return (left + 2.f * CANVAS_TOOLBAR_PADDING + CANVAS_TOOLBAR_BUTTON) * sc;
}

References Slic3r::GUI::CANVAS_TOOLBAR_BUTTON, Slic3r::GUI::CANVAS_TOOLBAR_MARGIN, Slic3r::GUI::CANVAS_TOOLBAR_PADDING, Slic3r::GUI::DPI_DEFAULT, Slic3r::GUI::get_dpi_for_window(), get_scale(), and Slic3r::GUI::NAVIGATOR_SIZE.

Here is the call graph for this function:

◆ get_canvas_type()

ECanvasType Slic3r::GUI::GLCanvas3D::get_canvas_type ( )

inline

953{ return m_canvas_type; }

References m_canvas_type.

Referenced by Slic3r::GUI::ObjectList::list_manipulation(), Slic3r::GUI::CommonGizmosDataObjects::InstancesHider::on_update(), Slic3r::GUI::NotificationManager::PopNotification::render(), Slic3r::GUI::GLCanvas3D::CenterOfMass::render_details(), Slic3r::GUI::Plater::priv::take_snapshot(), and Slic3r::GUI::Plater::priv::update_after_undo_redo().

Here is the caller graph for this function:

◆ get_clipping_planes()

const std::array< ClippingPlane, 2 > & Slic3r::GUI::GLCanvas3D::get_clipping_planes ( ) const

inline

1054{ return m_clipping_planes; };

References m_clipping_planes.

◆ get_collapse_toolbar_height()

float Slic3r::GUI::GLCanvas3D::get_collapse_toolbar_height ( ) const

{
    return collapse_side() != CollapseSide::None ? collapse_toolbar().get_height() : 0;
}

References collapse_side(), collapse_toolbar(), Slic3r::GUI::GLToolbar::get_height(), and Slic3r::GUI::None.

Referenced by _render_imgui_select_plate_toolbar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_collapse_toolbar_width()

float Slic3r::GUI::GLCanvas3D::get_collapse_toolbar_width ( ) const

{
    return collapse_side() != CollapseSide::None ? collapse_toolbar().get_width() : 0;
}

References collapse_side(), collapse_toolbar(), Slic3r::GUI::GLToolbar::get_width(), and Slic3r::GUI::None.

Referenced by _render_return_toolbar(), and get_main_toolbar_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_dark_mode_status()

const bool Slic3r::GUI::GLCanvas3D::get_dark_mode_status ( )

inline

983{ return m_is_dark; }

References m_is_dark.

◆ get_empty_cells()

std::vector< Vec2f > Slic3r::GUI::GLCanvas3D::get_empty_cells	(	const Vec2f	start_point,
		const Vec2f	step = {10, 10} )

{
    PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
    BoundingBoxf3 build_volume = plate->get_build_volume();
    Vec2d vmin(build_volume.min.x(), build_volume.min.y()), vmax(build_volume.max.x(), build_volume.max.y());
    BoundingBoxf bbox(vmin, vmax);
    std::vector<Vec2f> cells;
    std::vector<Vec2f> cells_ret;
    auto min_x = start_point.x() - step(0) * int((start_point.x() - bbox.min.x()) / step(0));
    auto min_y = start_point.y() - step(1) * int((start_point.y() - bbox.min.y()) / step(1));
    cells.reserve(((bbox.max.x() - min_x) / step(0)) * ((bbox.max.y() - min_y) / step(1)));
    cells_ret.reserve(cells.size());
    for (float x = min_x; x < bbox.max.x() - step(0) / 2; x += step(0))
        for (float y = min_y; y < bbox.max.y() - step(1) / 2; y += step(1))
        {
            cells.emplace_back(x, y);
        }
    for (size_t i = 0; i < m_model->objects.size(); ++i) {
        ModelObject* model_object = m_model->objects[i];
        auto id = model_object->id().id;
        ModelInstance* model_instance0 = model_object->instances.front();
        Polygon hull_2d = model_object->convex_hull_2d(Geometry::assemble_transform({ 0.0, 0.0, model_instance0->get_offset().z() }, model_instance0->get_rotation(),
            model_instance0->get_scaling_factor(), model_instance0->get_mirror()));
        if (hull_2d.empty())
            continue;
 
        const auto& instances = model_object->instances;
        double rotation_z0 = instances.front()->get_rotation().z();
        for (const auto& instance : instances) {
            Geometry::Transformation transformation;
            const Vec3d& offset = instance->get_offset();
            transformation.set_offset({ scale_(offset.x()), scale_(offset.y()), 0.0 });
            transformation.set_rotation(Z, instance->get_rotation().z() - rotation_z0);
            const Transform3d& trafo = transformation.get_matrix();
            Polygon inst_hull_2d = hull_2d.transform(trafo);
 
            for (auto it = cells.begin(); it != cells.end(); )
            {
                if (!inst_hull_2d.contains(Point(scale_(it->x()), scale_(it->y()))))
                    cells_ret.push_back(*it);
 
                it++;
            }
        }
    }
 
    Vec2f start = start_point;
    if (start_point(0) < 0 && start_point(1) < 0) {
        start(0) = bbox.center()(0);
        start(1) = bbox.center()(1);
    }
    std::sort(cells_ret.begin(), cells_ret.end(), [start](const Vec2f& cell1, const Vec2f& cell2) {return (cell1 - start).norm() < (cell2 - start).norm(); });
    return cells_ret;
}

References Slic3r::Geometry::assemble_transform(), Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::Polygon::contains(), Slic3r::ModelObject::convex_hull_2d(), Slic3r::MultiPoint::empty(), Slic3r::GUI::PartPlate::get_build_volume(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelInstance::get_mirror(), Slic3r::ModelInstance::get_offset(), Slic3r::ModelInstance::get_rotation(), Slic3r::ModelInstance::get_scaling_factor(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::ModelObject::instances, m_model, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::offset(), scale_, Slic3r::Geometry::Transformation::set_offset(), Slic3r::Geometry::Transformation::set_rotation(), Slic3r::Polygon::transform(), and Slic3r::Z.

Referenced by get_nearest_empty_cell().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_explosion_ratio()

float Slic3r::GUI::GLCanvas3D::get_explosion_ratio ( )

inline

980{ return m_explosion_ratio; }

References m_explosion_ratio.

◆ get_first_hover_volume_idx()

int Slic3r::GUI::GLCanvas3D::get_first_hover_volume_idx ( ) const

inline

1333{ return m_hover_volume_idxs.empty() ? -1 : m_hover_volume_idxs.front(); }

References m_hover_volume_idxs.

Referenced by Slic3r::GUI::get_first_hovered_gl_volume(), on_mouse(), and anonymous_namespace{SurfaceDrag.cpp}::start_dragging().

Here is the caller graph for this function:

◆ get_frame_profiler()

FrameProfiler & Slic3r::GUI::GLCanvas3D::get_frame_profiler ( )

inline

1391{ return m_frame_profiler; }

References m_frame_profiler.

◆ get_gcode_extruders_count()

size_t Slic3r::GUI::GLCanvas3D::get_gcode_extruders_count ( )

inline

1250{ return m_gcode_viewer.get_extruders_count(); }

References m_gcode_viewer.

◆ get_gcode_layers_times()

std::vector< float > Slic3r::GUI::GLCanvas3D::get_gcode_layers_times ( ) const

inline

1246{ return m_gcode_viewer.get_layers_times(); }

References m_gcode_viewer.

◆ get_gcode_layers_times_cache()

const std::vector< float > & Slic3r::GUI::GLCanvas3D::get_gcode_layers_times_cache ( ) const

inline

1247{ return m_gcode_layers_times_cache; }

Slic3r::GUI::GLCanvas3D::m_gcode_layers_times_cache

std::vector< float > m_gcode_layers_times_cache

Definition GLCanvas3D.hpp:837

References m_gcode_layers_times_cache.

◆ get_gcode_layers_zs()

std::vector< double > Slic3r::GUI::GLCanvas3D::get_gcode_layers_zs ( ) const

inline

1245{ return m_gcode_viewer.get_layers_zs(); }

References m_gcode_viewer.

◆ get_gcode_sequential_view()

const GCodeViewer::SequentialView & Slic3r::GUI::GLCanvas3D::get_gcode_sequential_view ( ) const

inline

1010{ return m_gcode_viewer.get_sequential_view(); }

References m_gcode_viewer.

◆ get_gcode_vertex_at()

const libvgcode::PathVertex & Slic3r::GUI::GLCanvas3D::get_gcode_vertex_at ( size_t id ) const

inline

1015{ return m_gcode_viewer.get_gcode_vertex_at(id); }

References m_gcode_viewer.

◆ get_gcode_view_enabled_range()

const libvgcode::Interval & Slic3r::GUI::GLCanvas3D::get_gcode_view_enabled_range ( ) const

inline

1013{ return m_gcode_viewer.get_gcode_view_enabled_range(); }

References m_gcode_viewer.

◆ get_gcode_view_full_range()

const libvgcode::Interval & Slic3r::GUI::GLCanvas3D::get_gcode_view_full_range ( ) const

inline

1012{ return m_gcode_viewer.get_gcode_view_full_range(); }

References m_gcode_viewer.

◆ get_gcode_view_type()

libvgcode::EViewType Slic3r::GUI::GLCanvas3D::get_gcode_view_type ( ) const

inline

1268{ return m_gcode_viewer.get_view_type(); }

References m_gcode_viewer.

◆ get_gcode_view_visible_range()

const libvgcode::Interval & Slic3r::GUI::GLCanvas3D::get_gcode_view_visible_range ( ) const

inline

1014{ return m_gcode_viewer.get_gcode_view_visible_range(); }

References m_gcode_viewer.

◆ get_gcode_viewer()

GCodeViewer & Slic3r::GUI::GLCanvas3D::get_gcode_viewer ( )

inline

1007{ return m_gcode_viewer; }

References m_gcode_viewer.

Referenced by _check_and_update_toolbar_icon_scale(), Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::begin_scene(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::go_to_layer(), handle_shortcut(), on_change_color_mode(), on_mouse_wheel(), Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::on_timer(), and Slic3r::GUI::GLCanvas3D::CenterOfMass::render().

Here is the caller graph for this function:

◆ get_gizmos_manager() [1/2]

GLGizmosManager & Slic3r::GUI::GLCanvas3D::get_gizmos_manager ( )

inline

1032{ return m_gizmos; }

References m_gizmos.

◆ get_gizmos_manager() [2/2]

const GLGizmosManager & Slic3r::GUI::GLCanvas3D::get_gizmos_manager ( ) const

inline

1031{ return m_gizmos; }

References m_gizmos.

Referenced by _render_objects(), Slic3r::GUI::add_volume_with_gizmo(), Slic3r::GUI::call_after_if_active(), anonymous_namespace{EmbossJob.cpp}::create_volume(), Slic3r::GUI::ObjectList::del_info_item(), Slic3r::GUI::anonymous_namespace{Plater.cpp}::emboss_svg(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), Slic3r::GUI::GLCanvas3D::CenterOfMass::render(), Slic3r::GUI::GLGizmoUtils::render_tooltip_button(), Slic3r::GUI::GLGizmoUtils::render_video_guide_button(), Slic3r::GUI::GLGizmoUtils::render_wiki_guide_button(), Slic3r::GUI::GizmoObjectManipulation::set_coordinates_type(), toggle_model_objects_visibility(), Slic3r::GUI::Plater::priv::undo_redo_to(), and Slic3r::GUI::Plater::priv::update_after_undo_redo().

Here is the caller graph for this function:

◆ get_hover_ghost_head()

int Slic3r::GUI::GLCanvas3D::get_hover_ghost_head ( ) const

inline

1334{ return m_hover_ghost_head; }

References m_hover_ghost_head.

◆ get_hover_ghost_plate()

int Slic3r::GUI::GLCanvas3D::get_hover_ghost_plate ( ) const

inline

1335{ return m_hover_ghost_plate; }

References m_hover_ghost_plate.

◆ get_local_mouse_position()

Vec2d Slic3r::GUI::GLCanvas3D::get_local_mouse_position ( ) const

{
    if (m_canvas == nullptr)
    return Vec2d::Zero();
 
    // Use the cached mouse position from event handlers (m_mouse.position)
    // instead of wxGetMousePosition() + ScreenToClient(), because
    // wxGetMousePosition() returns (0,0) on Wayland for global coords.
    // m_mouse.position already stores local canvas coordinates (set from
    // event.GetX(), event.GetY()) and is already scaled by the retina factor
    // in on_mouse(), so we can return it directly.
    return m_mouse.position;
}

References m_canvas, and m_mouse.

Referenced by Slic3r::GUI::GLCanvas3D::LayersEditing::get_cursor_z_relative().

Here is the caller graph for this function:

◆ get_main_toolbar_height()

int Slic3r::GUI::GLCanvas3D::get_main_toolbar_height ( ) const

inline

1137{ return m_main_toolbar.get_height(); }

References m_main_toolbar.

◆ get_main_toolbar_item_id()

int Slic3r::GUI::GLCanvas3D::get_main_toolbar_item_id ( const std::string & name ) const

inline

1393{ return m_main_toolbar.get_item_id(name); }

References m_main_toolbar.

Referenced by _init_main_toolbar().

Here is the caller graph for this function:

◆ get_main_toolbar_offset()

int Slic3r::GUI::GLCanvas3D::get_main_toolbar_offset ( ) const

{
    const float cnv_width              = get_canvas_size().get_width();
    const float collapse_toolbar_width = get_collapse_toolbar_width() * 2;
    const float gizmo_width            = m_gizmos.get_scaled_total_width();
    const float assemble_width         = m_assemble_view_toolbar.get_width();
    const float separator_width        = m_separator_toolbar.get_width();
    const float toolbar_total_width    = m_main_toolbar.get_width() + separator_width + gizmo_width + assemble_width + collapse_toolbar_width;
 
    if (cnv_width < toolbar_total_width) {
        return is_collapse_toolbar_on_left() ? collapse_toolbar_width : 0;
    } else {
        const float offset = (cnv_width - toolbar_total_width) / 2;
        return is_collapse_toolbar_on_left() ? offset + collapse_toolbar_width : offset;
    }
}

References get_canvas_size(), get_collapse_toolbar_width(), get_main_toolbar_offset(), is_collapse_toolbar_on_left(), m_assemble_view_toolbar, m_gizmos, m_main_toolbar, m_separator_toolbar, and Slic3r::offset().

Referenced by _render_assemble_view_toolbar(), _render_fps_overlay(), _render_main_toolbar(), _render_separator_toolbar_left(), _render_separator_toolbar_right(), and get_main_toolbar_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_main_toolbar_width()

int Slic3r::GUI::GLCanvas3D::get_main_toolbar_width ( ) const

inline

1138{ return m_main_toolbar.get_width(); }

References m_main_toolbar.

◆ get_model()

const Model * Slic3r::GUI::GLCanvas3D::get_model ( ) const

inline

1026{ return m_model; }

References m_model.

Referenced by Slic3r::GUI::calc_distance(), Slic3r::GUI::create_meshes(), anonymous_namespace{SurfaceDrag.cpp}::dragging(), Slic3r::GUI::face_selected_volume_to_camera(), Slic3r::GUI::GLCanvas3D::CenterOfMass::model_markers(), anonymous_namespace{EmbossJob.cpp}::start_create_volume_on_surface_job(), and anonymous_namespace{SurfaceDrag.cpp}::start_dragging().

Here is the caller graph for this function:

◆ get_move_volume_id()

int Slic3r::GUI::GLCanvas3D::get_move_volume_id ( ) const

inline

1332{ return m_mouse.drag.move_volume_idx; }

References m_mouse.

◆ get_nearest_empty_cell()

Vec2f Slic3r::GUI::GLCanvas3D::get_nearest_empty_cell	(	const Vec2f	start_point,
		const Vec2f	step = {10, 10} )

{
    std::vector<Vec2f> empty_cells = get_empty_cells(start_point, step);
    if (!empty_cells.empty())
        return empty_cells.front();
    else {
        double offset = get_size_proportional_to_max_bed_size(0.05);
        return { start_point(0) + offset, start_point(1) + offset };
    }
}

References get_empty_cells(), get_size_proportional_to_max_bed_size(), and Slic3r::offset().

Here is the call graph for this function:

◆ get_orient_settings()

OrientSettings & Slic3r::GUI::GLCanvas3D::get_orient_settings ( )

inline

    {
        PrinterTechnology ptech = this->current_printer_technology();
 
        auto* ptr = &this->m_orient_settings_fff;
 
        if (ptech == ptSLA) {
            ptr = &this->m_orient_settings_sla;
        }
 
        return *ptr;
    }

References current_printer_technology(), and Slic3r::ptSLA.

Referenced by _render_orient_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_overlay_window_width()

float Slic3r::GUI::GLCanvas3D::get_overlay_window_width ( )

inlineprivate

1662{ return 0; /*LayersEditing::get_overlay_window_width();*/ }

Referenced by _render_frame().

Here is the caller graph for this function:

◆ get_popup_menu_position()

const std::optional< Vec2d > & Slic3r::GUI::GLCanvas3D::get_popup_menu_position ( ) const

inline

1310{ return m_popup_menu_positon; }

References m_popup_menu_positon.

Referenced by Slic3r::GUI::add_volume_with_gizmo().

Here is the caller graph for this function:

◆ get_raycaster_clipping_plane()

ClippingPlane Slic3r::GUI::GLCanvas3D::get_raycaster_clipping_plane ( ) const

private

{
    // Orca: Ignore the gizmo clipping plane when the active tool does not apply it, and
    // invert the result into the convention expected by SceneRaycaster.
    GLGizmoBase* current_gizmo = m_gizmos.get_current();
    return ((!current_gizmo || current_gizmo->apply_clipping_plane()) ? _get_volumes_clipping_plane() :
                                                                       ClippingPlane::ClipsNothing())
        .inverted_normal();
}

References _get_volumes_clipping_plane(), Slic3r::GUI::GLGizmoBase::apply_clipping_plane(), Slic3r::GUI::ClippingPlane::ClipsNothing(), get_raycaster_clipping_plane(), and m_gizmos.

Referenced by _picking_pass(), get_camera_pan_anchor(), and get_raycaster_clipping_plane().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_raycasters_for_picking()

std::vector< std::shared_ptr< SceneRaycasterItem > > * Slic3r::GUI::GLCanvas3D::get_raycasters_for_picking ( SceneRaycaster::EType type )

inline

                                                                                                       {
        return m_scene_raycaster.get_raycasters(type);
    }

References m_scene_raycaster.

Referenced by _update_inactive_plates_visibility(), Slic3r::GUI::create_meshes(), toggle_model_objects_visibility(), and toggle_sla_auxiliaries_visibility().

Here is the caller graph for this function:

◆ get_scale()

const float Slic3r::GUI::GLCanvas3D::get_scale ( ) const

{
#if ENABLE_RETINA_GL
    return m_retina_helper->get_scale_factor();
#else
    return 1.0f;
#endif
}

Referenced by _check_and_update_toolbar_icon_scale(), _render_3d_navigator(), _render_arrange_menu(), _render_assemble_control(), _render_assemble_info(), _render_assembly_tooltip_button(), _render_canvas_toolbar(), _render_fps_overlay(), _render_frame(), _render_imgui_select_plate_toolbar(), _render_orient_menu(), _render_plate_switcher(), _render_section_view_panel(), get_canvas_toolbar_right(), Slic3r::GUI::marker_scale(), Slic3r::GUI::DesignSketchTool::render(), Slic3r::GUI::GLGizmoUtils::render_tooltip_button(), and Slic3r::GUI::GLCanvas3D::LayersEditing::render_variable_layer_height_dialog().

Here is the caller graph for this function:

◆ get_section_view_normal()

const Vec3d & Slic3r::GUI::GLCanvas3D::get_section_view_normal ( ) const

inline

1062{ return m_section_view->normal; }

References m_section_view.

◆ get_section_view_ratio()

double Slic3r::GUI::GLCanvas3D::get_section_view_ratio ( ) const

inline

1061{ return m_section_view->ratio; }

References m_section_view.

Referenced by _render_canvas_toolbar(), _render_section_view_panel(), and on_mouse_wheel().

Here is the caller graph for this function:

◆ get_selection() [1/2]

Selection & Slic3r::GUI::GLCanvas3D::get_selection ( )

inline

1029{ return m_selection; }

References m_selection.

◆ get_selection() [2/2]

const Selection & Slic3r::GUI::GLCanvas3D::get_selection ( ) const

inline

1028{ return m_selection; }

References m_selection.

Referenced by Slic3r::GUI::face_selected_volume_to_camera(), anonymous_namespace{GLGizmoEmboss.cpp}::fix_transformation(), Slic3r::GUI::CommonGizmosDataObjects::SelectionInfo::get_active_instance(), Slic3r::GUI::Plater::priv::get_curr_selection(), Slic3r::GUI::get_selected_gl_volume(), Slic3r::GUI::get_selection(), Slic3r::GUI::CommonGizmosDataObjects::SelectionInfo::on_update(), Slic3r::GUI::Plater::priv::scale_selection_to_fit_print_volume(), Slic3r::GUI::Plater::priv::set_current_panel(), Slic3r::GUI::Emboss::start_create_volume_without_position(), Slic3r::GUI::Plater::priv::update_after_undo_redo(), and Slic3r::GUI::ObjectList::update_selections_on_canvas().

Here is the caller graph for this function:

◆ get_separator_toolbar_height()

float Slic3r::GUI::GLCanvas3D::get_separator_toolbar_height ( ) const

inline

1143{ return m_separator_toolbar.get_height(); }

References m_separator_toolbar.

◆ get_separator_toolbar_width()

float Slic3r::GUI::GLCanvas3D::get_separator_toolbar_width ( ) const

inline

1142{ return m_separator_toolbar.get_width(); }

References m_separator_toolbar.

◆ get_show_bed()

bool Slic3r::GUI::GLCanvas3D::get_show_bed ( ) const

inline

1113{ return m_show_bed; }

References m_show_bed.

◆ get_size_proportional_to_max_bed_size()

double Slic3r::GUI::GLCanvas3D::get_size_proportional_to_max_bed_size ( double factor ) const

{
    const BoundingBoxf& bbox = m_bed.build_volume().bounding_volume2d();
    return factor * std::max(bbox.size()[0], bbox.size()[1]);
}

References m_bed, and Slic3r::BoundingBoxBase< PointType, APointsType >::size().

Referenced by get_nearest_empty_cell(), and Slic3r::GUI::Plater::increase_instances().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_use_clipping_planes()

bool Slic3r::GUI::GLCanvas3D::get_use_clipping_planes ( ) const

inline

1053{ return m_use_clipping_planes; }

References m_use_clipping_planes.

◆ get_volumes()

const GLVolumeCollection & Slic3r::GUI::GLCanvas3D::get_volumes ( ) const

inline

993{ return m_volumes; }

References m_volumes.

Referenced by Slic3r::GUI::create_meshes(), anonymous_namespace{SurfaceDrag.cpp}::dragging(), Slic3r::GUI::get_first_hovered_gl_volume(), Slic3r::GUI::get_selected_gl_volume(), Slic3r::GUI::GLCanvas3D::CenterOfMass::model_markers(), and anonymous_namespace{SurfaceDrag.cpp}::start_dragging().

Here is the caller graph for this function:

◆ get_volumes_count()

unsigned int Slic3r::GUI::GLCanvas3D::get_volumes_count ( ) const

inline

992{ return (unsigned int)m_volumes.volumes.size(); }

References m_volumes.

◆ get_wipe_tower_info()

GLCanvas3D::WipeTowerInfo Slic3r::GUI::GLCanvas3D::get_wipe_tower_info ( int plate_idx ) const

{
    WipeTowerInfo wti;
 
    for (const GLVolume* vol : m_volumes.volumes) {
        if (vol->is_wipe_tower && vol->object_idx() - 1000 == plate_idx) {
            DynamicPrintConfig& proj_cfg = wxGetApp().preset_bundle->project_config;
            wti.m_pos = Vec2d(proj_cfg.opt<ConfigOptionFloats>("wipe_tower_x")->get_at(plate_idx),
                              proj_cfg.opt<ConfigOptionFloats>("wipe_tower_y")->get_at(plate_idx));
            // BBS: don't support rotation
            //wti.m_rotation = (M_PI/180.) * proj_cfg->opt_float("wipe_tower_rotation_angle");
 
            auto& preset = wxGetApp().preset_bundle->prints.get_edited_preset();
            float wt_brim_width = preset.config.opt_float("prime_tower_brim_width");
 
            const BoundingBoxf3& bb = vol->bounding_box();
            if (wt_brim_width < 0) wt_brim_width = WipeTower::get_auto_brim_by_height((float)bb.max.z());
            wti.m_bb = BoundingBoxf{to_2d(bb.min), to_2d(bb.max)};
            wti.m_bb.offset(wt_brim_width);
 
            float brim_width = wxGetApp().preset_bundle->prints.get_edited_preset().config.opt_float("prime_tower_brim_width");
            if (brim_width < 0) brim_width = WipeTower::get_auto_brim_by_height((float) bb.max.z());
            wti.m_bb.offset((brim_width));
 
            // BBS: the wipe tower pos might be outside bed
            PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_plate(plate_idx);
            Vec2d plate_size = plate->get_size();
            wti.m_pos.x() = std::clamp(wti.m_pos.x(), 0.0, plate_size(0) - wti.m_bb.size().x());
            wti.m_pos.y() = std::clamp(wti.m_pos.y(), 0.0, plate_size(1) - wti.m_bb.size().y());
 
            // BBS: add partplate logic
            wti.m_plate_idx = plate_idx;
            break;
        }
    }
 
    return wti;
}

References Slic3r::GLVolume::bounding_box(), Slic3r::WipeTower::get_auto_brim_by_height(), Slic3r::GUI::PartPlate::get_size(), Slic3r::GUI::GLCanvas3D::WipeTowerInfo::m_bb, Slic3r::GUI::GLCanvas3D::WipeTowerInfo::m_plate_idx, Slic3r::GUI::GLCanvas3D::WipeTowerInfo::m_pos, m_volumes, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::GLVolume::object_idx(), Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), Slic3r::DynamicConfig::opt(), Slic3r::BoundingBoxBase< PointType, APointsType >::size(), and Slic3r::to_2d().

Here is the call graph for this function:

◆ get_wxglcanvas() [1/2]

wxGLCanvas * Slic3r::GUI::GLCanvas3D::get_wxglcanvas ( )

inline

955{ return m_canvas; }

References m_canvas.

Referenced by Slic3r::GUI::MainFrame::GLResourcesPrebuild::build_step(), Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::on_timer(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_variable_layer_height_dialog(), and Slic3r::GUI::GLCanvas3D::LayersEditing::thickness_bar_width().

Here is the caller graph for this function:

◆ get_wxglcanvas() [2/2]

const wxGLCanvas * Slic3r::GUI::GLCanvas3D::get_wxglcanvas ( ) const

inline

956{ return m_canvas; }

References m_canvas.

◆ GetHoverId()

int Slic3r::GUI::GLCanvas3D::GetHoverId ( )

{
    if (m_hover_plate_idxs.size() == 0) {
        return -1; }
    return m_hover_plate_idxs.front();
 
}

References GetHoverId(), and m_hover_plate_idxs.

Referenced by GetHoverId().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_layers_data_focus_event()

void Slic3r::GUI::GLCanvas3D::handle_layers_data_focus_event	(	const t_layer_height_range	range,
		const EditorType	type )

{
    std::string field = "layer_" + std::to_string(type) + "_" + std::to_string(range.first) + "_" + std::to_string(range.second);
    m_gizmos.reset_all_states();
    handle_sidebar_focus_event(field, true);
}

References handle_sidebar_focus_event(), m_gizmos, and Slic3r::range().

Here is the call graph for this function:

◆ handle_shortcut()

bool Slic3r::GUI::GLCanvas3D::handle_shortcut ( const KeyChord & chord )

{
    const ShortcutContext                       context = m_canvas_type == CanvasPreview ? ShortcutContext::Preview : ShortcutContext::Plater;
    const std::optional<ShortcutRegistry::Match> match   = wxGetApp().shortcuts().match(context, chord);
    if (!match.has_value())
        return false;
    const Shortcut shortcut = match->shortcut;
    const int      held     = match->step_modifiers;
    if (m_key_down.repeat && !shortcut_info(shortcut).repeatable)
        return true;
 
    const bool painting = dynamic_cast<GLGizmoPainterBase*>(m_gizmos.get_current()) != nullptr;
    const bool can_edit = m_canvas_type == CanvasView3D || m_canvas_type == CanvasAssembleView;
    auto edit_selection = [this](SelectionEdit::Kind kind, const Vec3d& direction) {
        if (!m_gizmos.is_enabled() || m_selection.is_empty() || m_canvas_type == CanvasAssembleView)
            return false;
        m_selection_edit.kind      = kind;
        m_selection_edit.key       = m_key_down.code;
        m_selection_edit.direction = direction;
        return true;
    };
    auto move_selection = [&](const Vec3d& direction) {
        if (edit_selection(SelectionEdit::Move, direction))
            apply_selection_move((held & wxMOD_SHIFT) != 0, (held & wxMOD_CONTROL) != 0);
    };
    auto rotate_selection = [&](double angle_z_rad) {
        if (edit_selection(SelectionEdit::Rotate, Vec3d::UnitZ()))
            apply_selection_rotate(angle_z_rad);
    };
    auto step_slider = [this, held](auto&& step) {
        IMSlider* layers = get_gcode_viewer().get_layers_slider();
        IMSlider* moves  = get_gcode_viewer().get_moves_slider();
        step(layers, moves, held != 0 ? 5 : 1);
        if (layers->is_dirty() && layers->is_one_layer())
            layers->SetLowerValue(layers->GetHigherValue());
        m_dirty = true;
    };
 
    switch (shortcut) {
    case Shortcut::SelectAll:
        if (!painting && !m_layers_editing.is_enabled())
            post_event(SimpleEvent(EVT_GLCANVAS_SELECT_CURR_PLATE_ALL));
        break;
    case Shortcut::SelectAllPlates:
        if (!painting && !m_layers_editing.is_enabled())
            post_event(SimpleEvent(EVT_GLCANVAS_SELECT_ALL));
        break;
    case Shortcut::Copy:  if (!painting) post_event(SimpleEvent(EVT_GLTOOLBAR_COPY)); break;
    case Shortcut::Paste: if (!painting) post_event(SimpleEvent(EVT_GLTOOLBAR_PASTE)); break;
    case Shortcut::Cut:   if (!painting) post_event(SimpleEvent(EVT_GLTOOLBAR_CUT)); break;
    case Shortcut::Undo:  if (can_edit) post_event(SimpleEvent(EVT_GLCANVAS_UNDO)); break;
    case Shortcut::Redo:  if (can_edit) post_event(SimpleEvent(EVT_GLCANVAS_REDO)); break;
    case Shortcut::DeleteSelected:
        if (!m_gizmos.on_delete_key())
            post_event(SimpleEvent(EVT_GLTOOLBAR_DELETE));
        break;
    case Shortcut::DeleteAll:      post_event(SimpleEvent(EVT_GLTOOLBAR_DELETE_ALL)); break;
    case Shortcut::CloneSelected:  post_event(SimpleEvent(EVT_GLTOOLBAR_CLONE)); break;
    case Shortcut::AddInstance:    post_event(Event<int>(EVT_GLCANVAS_INCREASE_INSTANCES, +1)); break;
    case Shortcut::RemoveInstance: post_event(Event<int>(EVT_GLCANVAS_INCREASE_INSTANCES, -1)); break;
    case Shortcut::TogglePrintable: post_event(SimpleEvent(EVT_GLCANVAS_PRINTABLE)); break;
    case Shortcut::Arrange:
        if (!m_gizmos.is_running())
            post_event(SimpleEvent(EVT_GLCANVAS_ARRANGE));
        break;
    case Shortcut::ArrangePlate:
        if (!m_gizmos.is_running())
            post_event(SimpleEvent(EVT_GLCANVAS_ARRANGE_PARTPLATE));
        break;
    case Shortcut::Orient:       post_event(SimpleEvent(EVT_GLCANVAS_ORIENT)); break;
    case Shortcut::OrientPlate:  post_event(SimpleEvent(EVT_GLCANVAS_ORIENT_PARTPLATE)); break;
    case Shortcut::RotateSelectionLeft:  rotate_selection(0.25 * M_PI); break;
    case Shortcut::RotateSelectionRight: rotate_selection(-0.25 * M_PI); break;
    case Shortcut::MoveSelectionLeft:  move_selection(-Vec3d::UnitX()); break;
    case Shortcut::MoveSelectionRight: move_selection(Vec3d::UnitX()); break;
    case Shortcut::MoveSelectionUp:    move_selection(Vec3d::UnitY()); break;
    case Shortcut::MoveSelectionDown:  move_selection(-Vec3d::UnitY()); break;
    case Shortcut::ZoomIn:  _update_camera_zoom(1.0); break;
    case Shortcut::ZoomOut: _update_camera_zoom(-1.0); break;
    case Shortcut::SwitchView: post_event(SimpleEvent(EVT_GLCANVAS_TAB)); break;
    case Shortcut::CollapseSidebar:
        if (!wxGetApp().is_gcode_viewer())
            post_event(SimpleEvent(EVT_GLCANVAS_COLLAPSE_SIDEBAR));
        break;
    case Shortcut::ShowWireframe:
        wxGetApp().plater()->toggle_show_wireframe();
        m_dirty = true;
        break;
    case Shortcut::Mouse3DSettings: {
        Mouse3DController& controller = wxGetApp().plater()->get_mouse3d_controller();
        if (controller.can_show_settings_dialog()) {
            controller.show_settings_dialog(!controller.is_settings_dialog_shown());
            m_dirty = true;
        }
        break;
    }
    case Shortcut::ReloadDevicePage:
        if (wxGetApp().mainframe->is_printer_view())
            wxGetApp().mainframe->load_printer_url();
        break;
    case Shortcut::KeyboardShortcuts: post_event(SimpleEvent(EVT_GLCANVAS_QUESTION_MARK)); break;
    case Shortcut::ToggleGcodeWindow:
        wxGetApp().toggle_show_gcode_window();
        m_dirty = true;
        request_extra_frame();
        break;
    case Shortcut::ToggleOneLayerMode:
        get_gcode_viewer().get_layers_slider()->switch_one_layer_mode();
        m_dirty = true;
        break;
    case Shortcut::ToggleBeltRawGcode:
        // Same state as the canvas view menu item. The designed-view back-transform is
        // baked into the toolpaths at load time, so the preview is re-converted.
        if (m_gcode_viewer.is_belt_view()) {
            m_gcode_viewer.toggle_belt_show_designed();
            if (Plater* plater = wxGetApp().plater())
                plater->refresh_belt_view();
            m_dirty = true;
        }
        break;
    case Shortcut::GoToLayer:
        if (!m_gizmos.is_enabled()) {
            get_gcode_viewer().get_layers_slider()->show_go_to_layer(true);
            m_dirty = true;
        }
        break;
    case Shortcut::LayerSliderUp:
    case Shortcut::LayerSliderDown:
        step_slider([up = shortcut == Shortcut::LayerSliderUp](IMSlider* layers, IMSlider* moves, int increment) {
            const int delta = up ? increment : -increment;
            if (layers->GetSelection() == ssHigher) {
                layers->SetHigherValue(layers->GetHigherValue() + delta);
                moves->SetHigherValue(moves->GetMaxValue());
            }
            else if (layers->GetSelection() == ssLower)
                layers->SetLowerValue(layers->GetLowerValue() + delta);
        });
        break;
    case Shortcut::MovesSliderLeft:
        step_slider([](IMSlider* layers, IMSlider* moves, int increment) {
            if (moves->GetHigherValue() == moves->GetMinValue() && layers->GetHigherValue() > layers->GetMinValue()) {
                layers->SetHigherValue(layers->GetHigherValue() - 1);
                moves->SetHigherValue(moves->GetMaxValue());
            }
            else
                moves->SetHigherValue(moves->GetHigherValue() - increment);
        });
        break;
    case Shortcut::MovesSliderRight:
        step_slider([](IMSlider* layers, IMSlider* moves, int increment) {
            if (moves->GetHigherValue() == moves->GetMaxValue() && layers->GetHigherValue() < layers->GetMaxValue()) {
                layers->SetHigherValue(layers->GetHigherValue() + 1);
                moves->SetHigherValue(moves->GetMinValue());
            }
            else
                moves->SetHigherValue(moves->GetHigherValue() + increment);
        });
        break;
    case Shortcut::MovesSliderStart:
    case Shortcut::MovesSliderEnd:
        step_slider([start = shortcut == Shortcut::MovesSliderStart](IMSlider*, IMSlider* moves, int) {
            moves->SetHigherValue(start ? moves->GetMinValue() : moves->GetMaxValue());
            moves->set_as_dirty();
        });
        break;
    default:
        if (!m_gizmos.open_gizmo_by_shortcut(shortcut))
            return false;
        m_dirty = true;
        break;
    }
    return true;
}

Referenced by on_char(), and on_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_sidebar_focus_event()

void Slic3r::GUI::GLCanvas3D::handle_sidebar_focus_event	(	const std::string &	opt_key,
		bool	focus_on )

{
    const std::string field = focus_on ? opt_key : "";
    // The gizmo panels report this on every build.
    if (m_sidebar_field == field)
        return;
    m_sidebar_field = field;
 
    //BBS: this event was sent from gizmo now, no need to clear gizmo
    //if (!m_sidebar_field.empty())
    //    m_gizmos.reset_all_states();
 
    m_dirty = true;
}

References m_dirty, and m_sidebar_field.

Referenced by handle_layers_data_focus_event().

Here is the caller graph for this function:

◆ has_mouse_capture()

bool Slic3r::GUI::GLCanvas3D::has_mouse_capture ( ) const

                                         {
    return m_canvas != nullptr && m_canvas->HasCapture();
}

References m_canvas.

Referenced by _render_frame(), and on_mouse().

Here is the caller graph for this function:

◆ has_toolpaths_to_export()

bool Slic3r::GUI::GLCanvas3D::has_toolpaths_to_export ( ) const

inline

1397{ return m_gcode_viewer.can_export_toolpaths(); }

References m_gcode_viewer.

◆ highlight_gizmo()

void Slic3r::GUI::GLCanvas3D::highlight_gizmo ( const std::string & gizmo_name )

{
    GLGizmosManager::EType gizmo = m_gizmos.get_gizmo_from_name(gizmo_name);
    if(gizmo == GLGizmosManager::EType::Undefined)
        return;
    m_gizmo_highlighter.init(&m_gizmos, gizmo, this);
}

References highlight_gizmo(), m_gizmo_highlighter, m_gizmos, and Slic3r::GUI::GLGizmosManager::Undefined.

Referenced by highlight_gizmo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ highlight_toolbar_item()

void Slic3r::GUI::GLCanvas3D::highlight_toolbar_item ( const std::string & item_name )

{
    GLToolbarItem* item = m_main_toolbar.get_item(item_name);
    if (!item || !item->is_visible())
        return;
    m_toolbar_highlighter.init(item, this);
}

References highlight_toolbar_item(), Slic3r::GUI::GLToolbarItem::is_visible(), m_main_toolbar, and m_toolbar_highlighter.

Referenced by highlight_toolbar_item().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init()

bool Slic3r::GUI::GLCanvas3D::init ( )

{
    if (m_initialized)
        return true;
 
    if (m_canvas == nullptr || m_context == nullptr)
        return false;
 
    // init dark mode status
    on_change_color_mode(wxGetApp().app_config->get("dark_color_mode") == "1", false);
 
    m_show_world_axes = wxGetApp().app_config->get("show_axes") == "true";
    
    // Controls the display of object names directly over the object
    m_labels.show(wxGetApp().app_config->get_bool("show_labels"));
    // Controls the color coding of overhang surfaces
    m_slope.globalUse(wxGetApp().app_config->get_bool("show_overhang"));
 
    BOOST_LOG_TRIVIAL(info) <<__FUNCTION__<< " enter";
    glsafe(::glClearColor(1.0f, 1.0f, 1.0f, 1.0f));
    glsafe(::glClearDepth(1.0f));
 
    glsafe(::glDepthFunc(GL_LESS));
 
    glsafe(::glEnable(GL_DEPTH_TEST));
    glsafe(::glEnable(GL_CULL_FACE));
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
    if (m_multisample_allowed)
        glsafe(::glEnable(GL_MULTISAMPLE));
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": before m_layers_editing init";
    if (m_main_toolbar.is_enabled())
        m_layers_editing.init();
 
    BOOST_LOG_TRIVIAL(info) <<__FUNCTION__<< ": before gizmo init";
    if (m_gizmos.is_enabled() && !m_gizmos.init())
        std::cout << "Unable to initialize gizmos: please, check that all the required textures are available" << std::endl;
 
    BOOST_LOG_TRIVIAL(info) <<__FUNCTION__<< ": before _init_toolbars";
    if (!_init_toolbars())
        return false;
 
    BOOST_LOG_TRIVIAL(info) <<__FUNCTION__<< ": finish _init_toolbars";
    if (m_selection.is_enabled() && !m_selection.init())
        return false;
 
    BOOST_LOG_TRIVIAL(info) <<__FUNCTION__<< ": finish m_selection";
 
#if ENABLE_IMGUI_STYLE_EDITOR
    //BBS load render color for style editor
    GLVolume::load_render_colors();
    PartPlate::load_render_colors();
    GLGizmoBase::load_render_colors();
    GLCanvas3D::load_render_colors();
    Bed3D::load_render_colors();
#endif
    //if (!wxGetApp().is_gl_version_greater_or_equal_to(3, 0))
    //    wxGetApp().plater()->enable_wireframe(false);
    m_initialized = true;
 
    return true;
}

References _init_toolbars(), GL_BLEND, GL_CULL_FACE, GL_DEPTH_TEST, GL_LESS, GL_MULTISAMPLE, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, glBlendFunc, glClearColor, glClearDepth, glDepthFunc, glEnable, glsafe, Slic3r::GLVolume::load_render_colors(), Slic3r::GUI::Bed3D::load_render_colors(), load_render_colors(), Slic3r::GUI::GLGizmoBase::load_render_colors(), Slic3r::GUI::PartPlate::load_render_colors(), m_canvas, m_context, m_gizmos, m_initialized, m_labels, m_layers_editing, m_main_toolbar, m_multisample_allowed, m_selection, m_show_world_axes, m_slope, and on_change_color_mode().

Referenced by _render_frame(), and Slic3r::GUI::MainFrame::GLResourcesPrebuild::build_step().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_gcode_viewer()

void Slic3r::GUI::GLCanvas3D::init_gcode_viewer	(	ConfigOptionMode	mode,
		Slic3r::PresetBundle *	preset_bundle )

inline

1008{ m_gcode_viewer.init(mode, preset_bundle); }

References m_gcode_viewer.

◆ is_all_plates_selected()

bool Slic3r::GUI::GLCanvas3D::is_all_plates_selected ( )

inline

997{ return m_sel_plate_toolbar.m_all_plates_stats_item && m_sel_plate_toolbar.m_all_plates_stats_item->selected; }

References m_sel_plate_toolbar.

◆ is_bed_visible()

bool Slic3r::GUI::GLCanvas3D::is_bed_visible ( ) const

private

{
    if (m_canvas_type == ECanvasType::CanvasPreview)
        return m_render_preview;
    if (m_canvas_type != ECanvasType::CanvasView3D || !m_show_bed)
        return false;
    if (!m_main_toolbar.is_enabled())
        return true;
 
    // The painting gizmos clip the selected instance at the plate (see InstancesHider), so the bed
    // mesh would sit in front of the part below it. They draw the plate and its grid instead (see
    // _render_scene) and the below-plate part as a translucent ghost.
    return !_is_below_plate_view_active();
}

References _is_below_plate_view_active(), CanvasPreview, CanvasView3D, is_bed_visible(), m_canvas_type, m_main_toolbar, m_render_preview, and m_show_bed.

Referenced by _render_scene(), get_camera_pan_anchor(), and is_bed_visible().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_camera_pan()

bool Slic3r::GUI::GLCanvas3D::is_camera_pan	(	const wxMouseEvent &	evt,
		const std::map< MouseButton, MouseAction > &	mappings ) const

{
    if (m_is_touchpad_navigation) {
        return evt.Moving() && evt.ShiftDown() && !evt.AltDown();
    } else {
        return evt.Dragging() && clicked_button_matches_action(evt, MouseAction::Pan, mappings);
        ;
    }
}

References clicked_button_matches_action(), m_is_touchpad_navigation, Pan, and Slic3r::GUI::wxMouseEvent.

Referenced by on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_camera_rotate()

bool Slic3r::GUI::GLCanvas3D::is_camera_rotate	(	const wxMouseEvent &	evt,
		const std::map< MouseButton, MouseAction > &	mappings ) const

{
    if (m_is_touchpad_navigation) {
        return evt.Moving() && evt.AltDown() && !evt.ShiftDown();
    } else {
        return evt.Dragging() && clicked_button_matches_action(evt, MouseAction::Rotation, mappings);
    }
}

References clicked_button_matches_action(), m_is_touchpad_navigation, Rotation, and Slic3r::GUI::wxMouseEvent.

Referenced by on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_collapse_toolbar_on_left()

bool Slic3r::GUI::GLCanvas3D::is_collapse_toolbar_on_left ( ) const

{
    return collapse_side() == CollapseSide::Left;
}

References collapse_side(), and Slic3r::GUI::Left.

Referenced by _render_imgui_select_plate_toolbar(), _render_return_toolbar(), and get_main_toolbar_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_dragging()

bool Slic3r::GUI::GLCanvas3D::is_dragging ( ) const

inline

1153{ return m_gizmos.is_dragging() || m_moving; }

References m_gizmos, and m_moving.

Referenced by Slic3r::GUI::GLCanvas3D::CenterOfMass::model_markers().

Here is the caller graph for this function:

◆ is_flushing_matrix_error()

bool Slic3r::GUI::GLCanvas3D::is_flushing_matrix_error ( )

private

                                          {
 
    // Flushing volumes only apply to single-extruder multi-material (SEMM) and BBL printers
    if (!Sidebar::should_show_SEMM_buttons())
        return false;
 
    std::vector<int> plate_extruders = wxGetApp().plater()->get_partplate_list().get_curr_plate()->get_extruders(true);
    if (plate_extruders.size() < 2)
        return false;
 
    const auto                &project_config = wxGetApp().preset_bundle->project_config;
    const std::vector<double> &config_matrix  = (project_config.option<ConfigOptionFloats>("flush_volumes_matrix"))->values;
    const std::vector<double> &config_multiplier = (project_config.option<ConfigOptionFloats>("flush_multiplier"))->values;
    return has_zero_flush_volume_for_used_filaments(config_matrix, config_multiplier, plate_extruders);
}

References Slic3r::has_zero_flush_volume_for_used_filaments(), is_flushing_matrix_error(), and Slic3r::GUI::Sidebar::should_show_SEMM_buttons().

Referenced by is_flushing_matrix_error(), and reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_frame_in_progress()

bool Slic3r::GUI::GLCanvas3D::is_frame_in_progress ( )

inlinestatic

989{ return s_frames_in_progress > 0; }

References s_frames_in_progress.

Referenced by Slic3r::GUI::UVEditorCanvas::on_size(), and Slic3r::GUI::UVEditorCanvas::render().

Here is the caller graph for this function:

◆ is_initialized()

bool Slic3r::GUI::GLCanvas3D::is_initialized ( ) const

inline

948{ return m_initialized; }

References m_initialized.

Referenced by _render_frame(), Slic3r::GUI::Plater::config_change_notification(), and Slic3r::GUI::Sidebar::update_mixed_filament_list().

Here is the caller graph for this function:

◆ is_layers_editing_allowed()

bool Slic3r::GUI::GLCanvas3D::is_layers_editing_allowed ( ) const

inline

1077{ return m_layers_editing.is_allowed(); }

References m_layers_editing.

◆ is_layers_editing_enabled()

bool Slic3r::GUI::GLCanvas3D::is_layers_editing_enabled ( ) const

inline

1076{ return m_layers_editing.is_enabled(); }

References m_layers_editing.

Referenced by _is_scene_cacheable(), _render_objects(), on_mouse(), and on_mouse_wheel().

Here is the caller graph for this function:

◆ is_mouse_dragging()

bool Slic3r::GUI::GLCanvas3D::is_mouse_dragging ( ) const

inline

1367{ return m_mouse.dragging; }

References m_mouse.

Referenced by Slic3r::GUI::ObjectList::OnContextMenu().

Here is the caller graph for this function:

◆ is_mouse_left_up_ignored()

bool Slic3r::GUI::GLCanvas3D::is_mouse_left_up_ignored ( ) const

inline

1371{ return m_mouse.ignore_left_up; }

References m_mouse.

◆ is_object_sinking()

bool Slic3r::GUI::GLCanvas3D::is_object_sinking ( int object_idx ) const

{
    for (const GLVolume* v : m_volumes.volumes) {
        if (v->object_idx() == object_idx && (v->is_sinking() || (!v->is_modifier && v->is_below_printbed())))
            return true;
    }
    return false;
}

References Slic3r::GLVolume::is_below_printbed(), Slic3r::GLVolume::is_sinking(), m_volumes, and Slic3r::GLVolume::object_idx().

Here is the call graph for this function:

◆ is_overhang_shown()

bool Slic3r::GUI::GLCanvas3D::is_overhang_shown ( ) const

inline

1405{ return m_slope.is_GlobalUsed(); }

References m_slope.

◆ is_reload_delayed()

bool Slic3r::GUI::GLCanvas3D::is_reload_delayed ( ) const

inline

1083{ return m_reload_delayed; }

References m_reload_delayed.

◆ is_rendering_enabled()

bool Slic3r::GUI::GLCanvas3D::is_rendering_enabled ( )

inline

    {
        return m_enable_render;
    }

References m_enable_render.

Referenced by Slic3r::GUI::Plater::config_change_notification().

Here is the caller graph for this function:

◆ is_section_view_active()

bool Slic3r::GUI::GLCanvas3D::is_section_view_active ( ) const

inline

1060{ return m_section_view->ratio > 0.; }

References m_section_view.

Referenced by _render_canvas_toolbar(), _render_section_view_panel(), and toggle_section_view().

Here is the caller graph for this function:

◆ is_using_slope()

bool Slic3r::GUI::GLCanvas3D::is_using_slope ( ) const

inline

1408{ return m_slope.is_used(); }

References m_slope.

◆ load_arrange_settings()

void Slic3r::GUI::GLCanvas3D::load_arrange_settings ( )

{
    // Each key must match what _render_arrange_menu writes, which appends a per-mode
    // postfix to the base name.
    auto load_float = [](const char *key, float &out) {
        // The menu writes these with float_to_string_decimal_point, so parse them back
        // the same way rather than with anything locale-dependent.
        std::string value = wxGetApp().app_config->get("arrange", key);
        size_t      parsed = 0;
        double      number = string_to_double_decimal_point(value, &parsed);
        if (parsed > 0)
            out = float(number);
    };
    auto load_bool = [](const char *key, bool &out) {
        std::string value = wxGetApp().app_config->get("arrange", key);
        if (!value.empty())
            out = (value == "1" || value == "true");
    };
 
    load_float("min_object_distance_fff",           m_arrange_settings_fff.distance);
    load_float("min_object_distance_fff_seq_print", m_arrange_settings_fff_seq_print.distance);
    load_float("min_object_distance_sla",           m_arrange_settings_sla.distance);
 
    load_bool("enable_rotation_fff",           m_arrange_settings_fff.enable_rotation);
    load_bool("enable_rotation_fff_seq_print", m_arrange_settings_fff_seq_print.enable_rotation);
    load_bool("enable_rotation_sla",           m_arrange_settings_sla.enable_rotation);
 
    // These two keys carry no postfix, so the one stored value covers both FFF modes.
    load_bool("allow_multi_materials_on_same_plate", m_arrange_settings_fff.allow_multi_materials_on_same_plate);
    load_bool("allow_multi_materials_on_same_plate", m_arrange_settings_fff_seq_print.allow_multi_materials_on_same_plate);
    load_bool("avoid_extrusion_cali_region",         m_arrange_settings_fff.avoid_extrusion_cali_region);
    load_bool("avoid_extrusion_cali_region",         m_arrange_settings_fff_seq_print.avoid_extrusion_cali_region);
 
    //BBS: add specific arrange settings
    m_arrange_settings_fff_seq_print.is_seq_print = true;
}

References load_arrange_settings(), m_arrange_settings_fff, m_arrange_settings_fff_seq_print, m_arrange_settings_sla, and Slic3r::string_to_double_decimal_point().

Referenced by GLCanvas3D(), and load_arrange_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_gcode_preview()

void Slic3r::GUI::GLCanvas3D::load_gcode_preview	(	const GCodeProcessorResult &	gcode_result,
		const std::vector< std::string > &	str_tool_colors,
		const std::vector< std::string > &	str_color_print_colors,
		bool	only_gcode )

{
    PartPlateList& partplate_list = wxGetApp().plater()->get_partplate_list();
    PartPlate* plate = partplate_list.get_curr_plate();
    const std::vector<BoundingBoxf3>& exclude_bounding_box = plate->get_exclude_areas();
 
    _set_shown_canvas_current();
 
    //BBS: init is called in GLCanvas3D.render()
    //when load gcode directly, it is too late
    m_gcode_viewer.init(wxGetApp().get_mode(), wxGetApp().preset_bundle);
    m_gcode_viewer.enable_legend(true);
 
 
    m_gcode_viewer.load_as_gcode(gcode_result, *this->fff_print(), str_tool_colors, str_color_print_colors, wxGetApp().plater()->build_volume(), exclude_bounding_box,
        wxGetApp().get_mode(), only_gcode);
    m_gcode_layers_times_cache = m_gcode_viewer.get_layers_times();
 
    m_gcode_viewer.get_moves_slider()->SetHigherValue(m_gcode_viewer.get_moves_slider()->GetMaxValue());
 
    if (wxGetApp().is_editor()) {
        //BBS: always load shell at preview, do this in load_shells
        _update_slice_error_status();
    }
 
    set_as_dirty();
    request_extra_frame();
}

References _set_shown_canvas_current(), _update_slice_error_status(), fff_print(), Slic3r::GUI::PartPlateList::get_curr_plate(), Slic3r::GUI::PartPlate::get_exclude_areas(), m_gcode_layers_times_cache, m_gcode_viewer, Slic3r::GUI::plater(), request_extra_frame(), and set_as_dirty().

Here is the call graph for this function:

◆ load_object() [1/2]

std::vector< int > Slic3r::GUI::GLCanvas3D::load_object	(	const Model &	model,
		int	obj_idx )

{
    if (0 <= obj_idx && obj_idx < (int)model.objects.size()) {
        const ModelObject* model_object = model.objects[obj_idx];
        if (model_object != nullptr)
            return load_object(*model_object, obj_idx, std::vector<int>());
    }
 
    return std::vector<int>();
}

References load_object(), and Slic3r::Model::objects.

Here is the call graph for this function:

◆ load_object() [2/2]

std::vector< int > Slic3r::GUI::GLCanvas3D::load_object	(	const ModelObject &	model_object,
		int	obj_idx,
		std::vector< int >	instance_idxs )

{
    if (instance_idxs.empty()) {
        for (unsigned int i = 0; i < model_object.instances.size(); ++i) {
            instance_idxs.emplace_back(i);
        }
    }
    return m_volumes.load_object(&model_object, obj_idx, instance_idxs, m_color_by, m_initialized);
}

References Slic3r::ModelObject::instances, m_color_by, m_initialized, and m_volumes.

Referenced by load_object().

Here is the caller graph for this function:

◆ load_render_colors()

void Slic3r::GUI::GLCanvas3D::load_render_colors ( )

staticprivate

{
    RenderColor::colors[RenderCol_3D_Background] = ImGuiWrapper::to_ImVec4(DEFAULT_BG_LIGHT_COLOR);
}

References Slic3r::RenderColor::colors, DEFAULT_BG_LIGHT_COLOR, RenderCol_3D_Background, and Slic3r::GUI::ImGuiWrapper::to_ImVec4().

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_shells()

void Slic3r::GUI::GLCanvas3D::load_shells	(	const Print &	print,
		bool	force_previewing = false )

{
    if (m_initialized)
    {
        _set_shown_canvas_current();
        m_gcode_viewer.load_shells(print, m_initialized, force_previewing);
        m_gcode_viewer.update_shells_color_by_extruder(m_config);
    }
}

References _set_shown_canvas_current(), m_config, m_gcode_viewer, and m_initialized.

Here is the call graph for this function:

◆ load_sla_preview()

void Slic3r::GUI::GLCanvas3D::load_sla_preview ( )

{
    const SLAPrint* print = sla_print();
    if (m_canvas != nullptr && print != nullptr) {
        _set_current();
      // Release OpenGL data before generating new data.
      reset_volumes();
        _load_sla_shells();
        _update_sla_shells_outside_state();
        _set_warning_notification_if_needed(EWarning::SlaSupportsOutside);
    }
}

References _load_sla_shells(), _set_current(), _set_warning_notification_if_needed(), _update_sla_shells_outside_state(), m_canvas, reset_volumes(), sla_print(), and SlaSupportsOutside.

Here is the call graph for this function:

◆ make_current_for_postinit()

bool Slic3r::GUI::GLCanvas3D::make_current_for_postinit ( )

                                           {
    return _set_current();
}

References _set_current().

Referenced by Slic3r::GUI::MainFrame::GLResourcesPrebuild::build_step().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mirror_selection()

void Slic3r::GUI::GLCanvas3D::mirror_selection ( Axis axis )

{
    TransformationType transformation_type;
    //transformation_type.set_world();
    transformation_type.set_relative();
    m_selection.setup_cache();
    m_selection.mirror(axis, transformation_type);
    do_mirror(L("Mirror object"));
    // BBS
    //wxGetApp().obj_manipul()->set_dirty();
}

References do_mirror(), L, m_selection, and Slic3r::GUI::TransformationType::set_relative().

Here is the call graph for this function:

◆ mouse_ray()

Linef3 Slic3r::GUI::GLCanvas3D::mouse_ray ( const Point & mouse_pos )

{
    float z0 = 0.0f;
    float z1 = 1.0f;
    return Linef3(_mouse_to_3d(mouse_pos, &z0), _mouse_to_3d(mouse_pos, &z1));
}

References _mouse_to_3d().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mouse_up_cleanup()

void Slic3r::GUI::GLCanvas3D::mouse_up_cleanup ( )

{
    // Both direct dragging and gizmo manipulation clear the expensive red
    // exclusion-intersection mesh while moving. Gizmo drags do not always set
    // m_mouse.dragging, so every completed mouse operation must allow the
    // cached preview to restore/recompute that mesh.
    if (PartPlate *plate = wxGetApp().plater()->get_partplate_list().get_curr_plate())
        plate->invalidate_exclusion_volume_preview();
 
    m_moving = false;
    m_camera_movement = false;
    m_mouse.drag.move_volume_idx = -1;
    m_mouse.set_start_position_3D_as_invalid();
    m_mouse.set_start_position_2D_as_invalid();
    m_mouse.dragging = false;
    m_mouse.ignore_left_up = false;
    m_mouse.ignore_right_up = false;
    m_dirty = true;
 
    if (m_canvas->HasCapture())
        m_canvas->ReleaseMouse();
}

References m_camera_movement, m_canvas, m_dirty, m_mouse, m_moving, and Slic3r::GUI::plater().

Referenced by on_mouse(), and Slic3r::GUI::ObjectList::OnContextMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ msw_rescale()

void Slic3r::GUI::GLCanvas3D::msw_rescale ( )

inline

1383{ m_gcode_viewer.invalidate_legend(); }

References m_gcode_viewer.

Referenced by Slic3r::GUI::Preview::msw_rescale().

Here is the caller graph for this function:

◆ on_change_color_mode()

void Slic3r::GUI::GLCanvas3D::on_change_color_mode	(	bool	is_dark,
		bool	reinit = true )

                                                               {
    m_is_dark = is_dark;
    // Bed color
    m_bed.on_change_color_mode(is_dark);
    // GcodeViewer color
    m_gcode_viewer.on_change_color_mode(is_dark);
    // ImGui Style
    wxGetApp().imgui()->on_change_color_mode(is_dark);
    // Notification
    wxGetApp().plater()->get_notification_manager()->on_change_color_mode(is_dark);
    // DailyTips Window
    wxGetApp().plater()->get_dailytips()->on_change_color_mode(is_dark);
    // Preview Slider
    IMSlider* m_layers_slider = get_gcode_viewer().get_layers_slider();
    IMSlider* m_moves_slider = get_gcode_viewer().get_moves_slider();
    m_layers_slider->on_change_color_mode(is_dark);
    m_moves_slider->on_change_color_mode(is_dark);
    // Partplate
    wxGetApp().plater()->get_partplate_list().on_change_color_mode(is_dark);
    // Plates toolbar - Reload All Stats button images
    _init_select_plate_toolbar();
 
    // Toolbar
    if (m_canvas_type == CanvasView3D) {
        m_gizmos.on_change_color_mode(is_dark);
        if (reinit) {
            // reset svg
            _switch_toolbars_icon_filename();
            m_gizmos.switch_gizmos_icon_filename();
            // set dirty to re-generate icon texture
            m_separator_toolbar.set_icon_dirty();
            m_main_toolbar.set_icon_dirty();
            collapse_toolbar().set_icon_dirty();
            m_assemble_view_toolbar.set_icon_dirty();
            m_gizmos.set_icon_dirty();
        }
    }
    if (m_canvas_type == CanvasAssembleView) {
        m_gizmos.on_change_color_mode(is_dark);
        if (reinit) {
            // reset svg
            m_gizmos.switch_gizmos_icon_filename();
            // set dirty to re-generate icon texture
            m_gizmos.set_icon_dirty();
        }
    }
    m_dirty = true;
}

References _init_select_plate_toolbar(), _switch_toolbars_icon_filename(), CanvasAssembleView, CanvasView3D, collapse_toolbar(), get_gcode_viewer(), Slic3r::GUI::GCodeViewer::get_layers_slider(), Slic3r::GUI::GCodeViewer::get_moves_slider(), is_dark(), m_assemble_view_toolbar, m_bed, m_canvas_type, m_dirty, m_gcode_viewer, m_gizmos, m_is_dark, m_main_toolbar, m_separator_toolbar, Slic3r::GUI::IMSlider::on_change_color_mode(), and Slic3r::GUI::GLToolbar::set_icon_dirty().

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_char()

void Slic3r::GUI::GLCanvas3D::on_char ( wxKeyEvent & evt )

{
    if (!m_initialized)
        return;
 
    // see include/wx/defs.h enum wxKeyCode
    int keyCode = evt.GetKeyCode();
 
    auto       imgui         = wxGetApp().imgui();
    const bool imgui_claimed = imgui->claim_key_event(evt);
    if (imgui->update_key_data(evt) || imgui_claimed)
        render();
    if (imgui_claimed)
        return;
 
    // Design tab: Delete, Esc, Ctrl+Z/Y and F are NOT handled here. DesignPanel's CHAR_HOOK owns
    // them (one route per key, whatever holds focus) and only lets a key through to this canvas
    // when an in-canvas value field is open -- which is exactly when Backspace must edit the
    // number rather than delete the geometry it measures.
 
    //BBS: add orient deactivate logic
    if (keyCode == WXK_ESCAPE
        && (_deactivate_arrange_menu() || _deactivate_orient_menu()))
        return;
 
    if (m_gizmos.on_char(evt))
        return;
 
    if (const KeyChord chord = KeyChord::from_event(evt); chord.is_punctuation() && handle_shortcut(chord))
        return;
 
    if (evt.HasModifiers()) {
        evt.Skip();
        return;
    }
 
    auto obj_list = wxGetApp().obj_list();
    switch (keyCode)
    {
    case WXK_ESCAPE: { deselect_all(); break; }
 
    // BBS: use keypad to change extruder
    case '1': {
        if (!m_timer_set_color.IsRunning()) {
            m_timer_set_color.StartOnce(500);
            break;
        }
    }
    case '0':   //Color logic for material 10
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9': {
        if (m_timer_set_color.IsRunning()) {
            if (keyCode < '7')  keyCode += 10;
            m_timer_set_color.Stop();
        }
        if (m_gizmos.get_current_type() != GLGizmosManager::MmSegmentation)
            obj_list->set_extruder_for_selected_items(keyCode - '0');
        break;
    }
    default:  { evt.Skip(); break; }
    }
}

References _deactivate_arrange_menu(), _deactivate_orient_menu(), deselect_all(), Slic3r::GUI::KeyChord::from_event(), handle_shortcut(), m_gizmos, m_initialized, m_timer_set_color, Slic3r::GUI::GLGizmosManager::MmSegmentation, Slic3r::GUI::obj_list(), and render().

Referenced by bind_event_handlers(), Slic3r::GUI::Plater::search(), and unbind_event_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_fps_overlay_timer()

void Slic3r::GUI::GLCanvas3D::on_fps_overlay_timer ( wxTimerEvent & evt )

{
    m_fps_overlay_tick = true;
    _set_overlay_as_dirty();
    wxWakeUpIdle();
}

References _set_overlay_as_dirty(), and m_fps_overlay_tick.

Referenced by GLCanvas3D().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_gesture()

void Slic3r::GUI::GLCanvas3D::on_gesture ( wxGestureEvent & evt )

{
    if (!m_initialized || !_set_current())
        return;
 
    auto & camera = wxGetApp().plater()->get_camera();
    if (evt.GetEventType() == wxEVT_GESTURE_PAN) {
        // Orca: Gesture coordinates must use framebuffer pixels, and one stable world-space
        // anchor must be retained for the complete gesture to prevent perspective drift.
        const auto p = evt.GetPosition();
        auto d = static_cast<wxPanGestureEvent&>(evt).GetDelta();
        Vec2d screen_position(p.x, p.y);
        Vec2d screen_delta(d.x, d.y);
        apply_retina_scale(screen_position);
        apply_retina_scale(screen_delta);
        if (evt.IsGestureStart() || !m_gesture_pan_anchor.has_value())
            m_gesture_pan_anchor = get_camera_pan_anchor(camera, ECameraNavigationType::Gesture,
                screen_position - screen_delta);
        pan_camera(camera, screen_delta, *m_gesture_pan_anchor);
        if (evt.IsGestureEnd())
            m_gesture_pan_anchor.reset();
    } else if (evt.GetEventType() == wxEVT_GESTURE_ZOOM) {
        static float zoom_start = 1;
        if (evt.IsGestureStart())
            zoom_start = camera.get_zoom();
        camera.set_zoom(zoom_start * static_cast<wxZoomGestureEvent&>(evt).GetZoomFactor());
    } else if (evt.GetEventType() == wxEVT_GESTURE_ROTATE) {
        // Orca: Rotation starts a different navigation operation, so a previous pan anchor
        // must not be reused; rotation and pan fallbacks share the same navigation pivot.
        m_gesture_pan_anchor.reset();
        bool rotate_limit = current_printer_technology() != ptSLA;
        static double last_rotate = 0;
        if (evt.IsGestureStart())
            last_rotate = 0;
        auto rotate = static_cast<wxRotateGestureEvent&>(evt).GetRotationAngle() - last_rotate;
        last_rotate += rotate;
        const std::optional<Vec3d> rotate_target = get_camera_orbit_target(ECameraNavigationType::Gesture);
        if (rotate_target.has_value())
            camera.rotate_on_sphere_with_target(-rotate, 0, rotate_limit, *rotate_target);
        else
            camera.rotate_on_sphere(-rotate, 0, rotate_limit);
        camera.auto_type(Camera::EType::Perspective);
    }
    m_dirty = true;
}

References _set_current(), apply_retina_scale(), camera, current_printer_technology(), Gesture, get_camera_orbit_target(), get_camera_pan_anchor(), m_dirty, m_gesture_pan_anchor, m_initialized, Slic3r::GUI::pan_camera(), Slic3r::GUI::Camera::Perspective, and Slic3r::ptSLA.

Referenced by bind_event_handlers(), and unbind_event_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_idle()

void Slic3r::GUI::GLCanvas3D::on_idle ( wxIdleEvent & evt )

{
    if (!m_initialized || m_benchmarking)
        return;
 
    // Toolbar states, notifications and ImGui's own layout settling only touch the overlay.
    m_overlay_dirty |= m_main_toolbar.update_items_state();
    //BBS: GUI refactor: GLToolbar
    m_overlay_dirty |= m_assemble_view_toolbar.update_items_state();
    // BBS
    //m_dirty |= wxGetApp().plater()->get_view_toolbar().update_items_state();
    m_overlay_dirty |= collapse_toolbar().update_items_state();
    // apply() DRAINS the 3D-mouse queue, so only the canvas actually on screen may call it: a
    // hidden canvas renders nothing, so the motion it swallowed moves the shared camera without
    // ever being drawn and the next visible frame jumps several states at once.
    bool mouse3d_controller_applied = _is_shown_on_screen()
        && wxGetApp().plater()->get_mouse3d_controller().apply(wxGetApp().plater()->get_camera());
    m_dirty |= mouse3d_controller_applied;
    m_overlay_dirty |= wxGetApp().plater()->get_notification_manager()->update_notifications(*this);
    auto gizmo = wxGetApp().plater()->get_view3D_canvas3D()->get_gizmos_manager().get_current();
    if (gizmo != nullptr) m_dirty |= gizmo->update_items_state();
#if ENABLE_ENHANCED_IMGUI_SLIDER_FLOAT
    // ImGuiWrapper::m_requires_extra_frame may have been set by a render made outside of the OnIdle mechanism
    bool imgui_requires_extra_frame = wxGetApp().imgui()->requires_extra_frame();
    m_overlay_dirty |= imgui_requires_extra_frame;
#endif // ENABLE_ENHANCED_IMGUI_SLIDER_FLOAT
    m_dirty |= GLTexture::Compressor::has_compressed_texture_to_refresh();
 
    if (!m_dirty && !m_overlay_dirty)
        return;
 
#if ENABLE_ENHANCED_IMGUI_SLIDER_FLOAT
    // this needs to be done here.
    // during the render launched by the refresh the value may be set again
    wxGetApp().imgui()->reset_requires_extra_frame();
#endif // ENABLE_ENHANCED_IMGUI_SLIDER_FLOAT
 
    const int fps_cap = _get_effective_fps_cap();
    if (fps_cap > 0) {
        const auto now = std::chrono::steady_clock::now();
        const auto min_frame_time = std::chrono::duration<double>(1.0 / static_cast<double>(fps_cap));
        const auto elapsed = now - m_last_frame_start_time;
        if (elapsed < min_frame_time) {
            const int wait_ms = std::max(1, static_cast<int>(std::ceil(std::chrono::duration<double, std::milli>(min_frame_time - elapsed).count())));
            schedule_extra_frame(wait_ms);
            evt.RequestMore();
            return;
        }
 
        // Pace by frame-start interval so rendering time is part of the target budget.
        m_last_frame_start_time = now;
    }
 
    // Read and cleared before the render; a request made during it is left for the next frame.
    const bool scene_dirty = m_dirty;
    m_dirty = false;
    m_overlay_dirty = false;
    _refresh_if_shown_on_screen(scene_dirty);
 
    if (m_extra_frame_requested || mouse3d_controller_applied) {
        m_dirty = true;
        m_extra_frame_requested = false;
        evt.RequestMore();
    }
#if ENABLE_ENHANCED_IMGUI_SLIDER_FLOAT
    else if (imgui_requires_extra_frame || wxGetApp().imgui()->requires_extra_frame()) {
        // ImGui settling a window or fading a tooltip.
        m_overlay_dirty = true;
        evt.RequestMore();
    }
#endif // ENABLE_ENHANCED_IMGUI_SLIDER_FLOAT
}

References _get_effective_fps_cap(), _is_shown_on_screen(), _refresh_if_shown_on_screen(), collapse_toolbar(), count, get_camera(), Slic3r::GUI::GLTexture::Compressor::has_compressed_texture_to_refresh(), m_assemble_view_toolbar, m_benchmarking, m_dirty, m_extra_frame_requested, m_initialized, m_last_frame_start_time, m_main_toolbar, m_overlay_dirty, Slic3r::GUI::plater(), schedule_extra_frame(), and Slic3r::GUI::GLToolbar::update_items_state().

Referenced by bind_event_handlers(), and unbind_event_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_key()

void Slic3r::GUI::GLCanvas3D::on_key ( wxKeyEvent & evt )

{
#ifdef __APPLE__
    // A key the input method used for a composition must not also edit the text field: Esc would revert
    // it, Backspace delete a character, Enter add a line.
    if (evt.GetEventType() == wxEVT_KEY_DOWN && mac_ime_owns_key(m_canvas->GetHandle()))
        return;
#endif
 
    auto       imgui         = wxGetApp().imgui();
    const int  keyCode       = evt.GetKeyCode();
    const bool imgui_claimed = imgui->claim_key_event(evt);
    if (evt.GetEventType() == wxEVT_KEY_DOWN)
        m_key_down = { keyCode, key_repeats(keyCode) };
    else if (evt.GetEventType() == wxEVT_KEY_UP)
        key_released(keyCode);
    const bool alt_wheel_released = evt.GetEventType() == wxEVT_KEY_UP && keyCode == WXK_ALT && std::exchange(m_alt_wheel_used, false);
 
    // ImGui closes a popup on Esc only through keyboard navigation, which is off.
    if (imgui_claimed && evt.GetEventType() == wxEVT_KEY_DOWN && keyCode == WXK_ESCAPE)
        imgui->close_top_popup();
    if (imgui->update_key_data(evt) || imgui_claimed)
        render();
    if (!imgui_claimed)
    {
        // Before the gizmos and the selection, which Esc also closes.
        if (evt.GetEventType() == wxEVT_KEY_DOWN && keyCode == WXK_ESCAPE && std::exchange(m_section_view->panel_open, false)) {
            _set_overlay_as_dirty();
            return;
        }
        if (!m_gizmos.on_key(evt)) {
            if (evt.GetEventType() == wxEVT_KEY_UP) {
                if (evt.ShiftDown() && evt.ControlDown() && keyCode == WXK_SPACE) {
#if !BBL_RELEASE_TO_PUBLIC
                    wxGetApp().plater()->toggle_render_statistic_dialog();
                    m_dirty = true;
#endif
                }
                else if (keyCode == WXK_SHIFT) {
                    if (m_picking_enabled && m_rectangle_selection.is_dragging()) {
                        _update_selection_from_hover();
                        m_rectangle_selection.stop_dragging();
                        m_mouse.ignore_left_up = true;
                        m_dirty = true;
                    }
//                    set_cursor(Standard);
                }
                else if (keyCode == WXK_ALT) {
                    if (m_picking_enabled && m_rectangle_selection.is_dragging()) {
                        _update_selection_from_hover();
                        m_rectangle_selection.stop_dragging();
                        m_mouse.ignore_left_up = true;
                        m_dirty = true;
                    }
//                    set_cursor(Standard);
#ifdef __WXMSW__
                    if (m_camera_movement && m_is_touchpad_navigation) {
                        m_camera_movement = false;
                        m_mouse.set_start_position_3D_as_invalid();
                    }
#endif
                }
                else if (keyCode == WXK_CONTROL)
                    m_dirty = true;
                else if (m_selection_edit.kind != SelectionEdit::None && keyCode == m_selection_edit.key)
                    finish_selection_edit();
            }
            else if (evt.GetEventType() == wxEVT_KEY_DOWN) {
                if (handle_shortcut(KeyChord::from_event(evt)))
                    return;
                if (keyCode == WXK_SHIFT) {
                    if (m_selection_edit.kind == SelectionEdit::Move)
                        apply_selection_move(true, evt.CmdDown());
 
                    if (m_picking_enabled /*&& (m_gizmos.get_current_type() != GLGizmosManager::SlaSupports)*/)
                    {
                        m_mouse.ignore_left_up = false;
//                        set_cursor(Cross);
                    }
                }
                else if (keyCode == WXK_ALT) {
                    if (m_picking_enabled /*&& (m_gizmos.get_current_type() != GLGizmosManager::SlaSupports)*/)
                    {
                        m_mouse.ignore_left_up = false;
//                        set_cursor(Cross);
                    }
                }
                else if (keyCode == WXK_CONTROL)
                    m_dirty = true;
            }
        }
        else return;
    }
 
    if (keyCode != WXK_TAB
        && keyCode != WXK_LEFT
        && keyCode != WXK_UP
        && keyCode != WXK_RIGHT
        && keyCode != WXK_DOWN
        && !alt_wheel_released) {
        evt.Skip();   // Needed to have EVT_CHAR generated as well
    }
}

References _set_overlay_as_dirty(), _update_selection_from_hover(), apply_selection_move(), finish_selection_edit(), Slic3r::GUI::KeyChord::from_event(), handle_shortcut(), Slic3r::GUI::key_released(), Slic3r::GUI::key_repeats(), m_alt_wheel_used, m_camera_movement, m_canvas, m_dirty, m_gizmos, m_is_touchpad_navigation, m_key_down, m_mouse, m_picking_enabled, m_rectangle_selection, m_section_view, m_selection_edit, Slic3r::GUI::mac_ime_owns_key(), Slic3r::GUI::GLCanvas3D::SelectionEdit::Move, Slic3r::GUI::GLCanvas3D::SelectionEdit::None, and render().

Referenced by bind_event_handlers(), release_held_modifiers(), and unbind_event_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_mouse()

void Slic3r::GUI::GLCanvas3D::on_mouse ( wxMouseEvent & evt )

{
    if (!m_initialized || !_set_current())
        return;
 
    // BBS: single snapshot
    Plater::SingleSnapshot single(wxGetApp().plater());
 
#ifdef __WXMAC__
    // On macOS, the mouse key state is only present for mouse btn related events such as wxEVT_LEFT_DOWN.
    // For other events, all buttons are reported as non-pressed, such as window leaving event. This causes
    // imgui stopped responding if cursor moved out of window, such as
    // https://github.com/OrcaSlicer/OrcaSlicer/pull/14999#issuecomment-5151344759
    // We solve this by correcting the state of the event from the actual mouse state querying with `wxGetMouseState()`
    // so it works like on other platforms.
    // Only fill in state the event does not carry, to preserve wx's synthetic right button for Ctrl+left.
    if (!evt.ButtonIsDown(wxMOUSE_BTN_ANY)) {
        const auto state = wxGetMouseState();
        evt.SetLeftDown(state.LeftIsDown());
        evt.SetMiddleDown(state.MiddleIsDown());
        evt.SetRightDown(state.RightIsDown());
        evt.SetAux1Down(state.Aux1IsDown());
        evt.SetAux2Down(state.Aux2IsDown());
    }
#endif
 
#if ENABLE_RETINA_GL
    const float scale = m_retina_helper->get_scale_factor();
    evt.SetX(evt.GetX() * scale);
    evt.SetY(evt.GetY() * scale);
#endif
 
    Point pos(evt.GetX(), evt.GetY());
 
    ImGuiWrapper* imgui = wxGetApp().imgui();
    if (m_tooltip.is_in_imgui() && evt.LeftUp())
        // ignore left up events coming from imgui windows and not processed by them
        m_mouse.ignore_left_up = true;
    m_tooltip.set_in_imgui(false);
 
    // while a non-ImGui drag is already in progress (gizmo grabber, object move, rectangle selection, layer editing),
    // don't let ImGui/ImGuizmo claim the event just because the cursor is hovering something like the navigator cube
    // that incorrectly suppresses the active drag's tooltip and can interrupt its processing. The active drag always takes priority.
    const bool other_drag_active = m_gizmos.is_dragging() || m_mouse.dragging || m_rectangle_selection.is_dragging() || m_layers_editing.state == LayersEditing::Editing;
 
    if (imgui->update_mouse_data(evt) && !other_drag_active) {
        if ((evt.LeftDown() || (evt.Moving() && (evt.AltDown() || evt.ShiftDown()))) && m_canvas != nullptr)
            m_canvas->SetFocus();
        m_mouse.position = evt.Leaving() ? Vec2d(-1.0, -1.0) : pos.cast<double>();
        m_tooltip.set_in_imgui(true);
 
        // ORCA keep tracking mouse position while drag active and cursor not in window bounds
        const bool imgui_dragging_active = (GImGui != nullptr && ImGui::GetIO().MouseDown[0] && GImGui->ActiveId != 0) || m_navigator_dragging;
        if (!has_mouse_capture() && imgui_dragging_active)
            m_canvas->CaptureMouse();
 
        // release capture as soon as the button goes up
        if (evt.LeftUp() || evt.MiddleUp() || evt.RightUp())
            mouse_up_cleanup();
 
        // Hovering an ImGui window only changes the overlay.
        const bool overlay_only = evt.Moving() && !m_mouse.dragging;
        // ImGui takes a press or a release only inside a frame. Motion is rendered from on_idle().
        if (evt.ButtonDown() || evt.ButtonUp() || evt.ButtonDClick())
            _render_frame(true);
#ifdef SLIC3R_DEBUG_MOUSE_EVENTS
        printf((format_mouse_event_debug_message(evt) + " - Consumed by ImGUI\n").c_str());
#endif /* SLIC3R_DEBUG_MOUSE_EVENTS */
        if (overlay_only)
            _set_overlay_as_dirty();
        else
            m_dirty = true;
        // do not return if dragging or tooltip not empty to allow for tooltip update
        // also, do not return if the mouse is moving and also is inside MM gizmo to allow update seed fill selection
        if (!m_mouse.dragging && m_tooltip.is_empty() && (m_gizmos.get_current_type() != GLGizmosManager::MmSegmentation || !evt.Moving()))
            return;
    }
 
    // Design tab: the interactive sketch tool owns the mouse whenever it has
    // something on screen — an active session OR committed sketch overlays that the user
    // can click to select. It runs after ImGui (so dialogs still work) but before
    // camera/toolbar/gizmo handling; on_mouse returns false for events it doesn't consume
    // (drag/orbit/wheel) so the camera keeps working over the display-only plate.
#ifdef SLIC3R_CAD
    if (m_design_sketch_tool != nullptr && m_design_sketch_tool->has_display()) {
        // Except over the sidebar collapse button, which is drawn over the sketch.
        if (collapse_toolbar().on_mouse(evt, *this)) {
            if (evt.LeftUp() || evt.MiddleUp() || evt.RightUp())
                mouse_up_cleanup();
            m_mouse.set_start_position_3D_as_invalid();
            return;
        }
        if (evt.LeftDown() && m_canvas != nullptr)
            m_canvas->SetFocus();   // grab keyboard focus so Delete/keys reach this canvas
        // A Touchpad-style orbit or pan (a plain move with Alt or Shift held) is the camera's,
        // whatever the tool would make of the move. Only a drag consults the button mappings.
        const bool camera_move = evt.Moving() && (is_camera_rotate(evt, {}) || is_camera_pan(evt, {}));
        if (!camera_move && m_design_sketch_tool->on_mouse(evt, *this)) {
            m_dirty = true;
            render();   // force an immediate redraw so the sketch overlay updates live
            return;
        }
    }
#endif
 
#ifdef __WXMSW__
  bool on_enter_workaround = false;
    if (! evt.Entering() && ! evt.Leaving() && m_mouse.position.x() == -1.0) {
        // Workaround for SPE-832: There seems to be a mouse event sent to the window before evt.Entering()
        m_mouse.position = pos.cast<double>();
        render();
#ifdef SLIC3R_DEBUG_MOUSE_EVENTS
    printf((format_mouse_event_debug_message(evt) + " - OnEnter workaround\n").c_str());
#endif /* SLIC3R_DEBUG_MOUSE_EVENTS */
    on_enter_workaround = true;
    } else
#endif /* __WXMSW__ */
    {
#ifdef SLIC3R_DEBUG_MOUSE_EVENTS
    printf((format_mouse_event_debug_message(evt) + " - other\n").c_str());
#endif /* SLIC3R_DEBUG_MOUSE_EVENTS */
    }
    const int selected_object_idx      = m_selection.get_object_idx();
    const int layer_editing_object_idx = is_layers_editing_enabled() ? selected_object_idx : -1;
    const bool mouse_in_layer_editing  = layer_editing_object_idx != -1 && m_layers_editing.bar_rect_contains(*this, pos(0), pos(1));
 
    if (!mouse_in_layer_editing && m_main_toolbar.on_mouse(evt, *this)) {
        if (m_main_toolbar.is_any_item_pressed())
            m_gizmos.reset_all_states();
        if (evt.LeftUp() || evt.MiddleUp() || evt.RightUp())
            mouse_up_cleanup();
        m_mouse.set_start_position_3D_as_invalid();
        return;
    }
 
    //BBS: GUI refactor: GLToolbar
    if (!mouse_in_layer_editing && m_assemble_view_toolbar.on_mouse(evt, *this)) {
        if (evt.LeftUp() || evt.MiddleUp() || evt.RightUp())
            mouse_up_cleanup();
        m_mouse.set_start_position_3D_as_invalid();
        return;
    }
 
    if (!mouse_in_layer_editing && collapse_toolbar().on_mouse(evt, *this)) {
        if (evt.LeftUp() || evt.MiddleUp() || evt.RightUp())
            mouse_up_cleanup();
        m_mouse.set_start_position_3D_as_invalid();
        return;
    }
 
    // BBS
#if 0
    if (wxGetApp().plater()->get_view_toolbar().on_mouse(evt, *this)) {
        if (evt.LeftUp() || evt.MiddleUp() || evt.RightUp())
            mouse_up_cleanup();
        m_mouse.set_start_position_3D_as_invalid();
        return;
    }
#endif
 
    for (GLVolume* volume : m_volumes.volumes) {
        volume->force_sinking_contours = false;
    }
 
    auto show_sinking_contours = [this]() {
        const Selection::IndicesList& idxs = m_selection.get_volume_idxs();
        for (unsigned int idx : idxs) {
            m_volumes.volumes[idx]->force_sinking_contours = true;
        }
        m_dirty = true;
    };
 
    if (!mouse_in_layer_editing && m_gizmos.on_mouse(evt)) {
        if (m_gizmos.is_running()) {
            _deactivate_arrange_menu();
            _deactivate_orient_menu();
            _deactivate_layersediting_menu();
        }
        if (wxWindow::FindFocus() != m_canvas)
            // Grab keyboard focus for input in gizmo dialogs.
            m_canvas->SetFocus();
 
        if (evt.LeftDown()) {
            // Clear hover state in main toolbar
            wxMouseEvent evt2 = evt;
            evt2.SetEventType(wxEVT_MOTION);
            evt2.SetLeftDown(false);
            m_main_toolbar.on_mouse(evt2, *this);
        }
 
        // ORCA keep tracking mouse position while drag active and cursor not in window bounds
        if (!has_mouse_capture() && evt.LeftIsDown() && m_gizmos.is_dragging())
            m_canvas->CaptureMouse();
 
        if (evt.LeftUp() || evt.MiddleUp() || evt.RightUp())
            mouse_up_cleanup();
 
        m_mouse.set_start_position_3D_as_invalid();
        m_mouse.position = pos.cast<double>();
 
        // It should be detection of volume change
        // Not only detection of some modifiers !!!
        if (evt.Dragging()) {
            if (PartPlate *plate = wxGetApp().plater()->get_partplate_list().get_curr_plate())
                plate->clear_exclusion_volume_intersections();
            GLGizmosManager::EType c = m_gizmos.get_current_type();
            if (current_printer_technology() == ptFFF &&
                (fff_print()->config().print_sequence == PrintSequence::ByObject)) {
                if (can_sequential_clearance_show_in_gizmo())
                    update_sequential_clearance();
            } else {
                // Orca: by-layer counterpart, for a prime tower compacted by "No sparse layers".
                if (current_printer_technology() == ptFFF && can_sequential_clearance_show_in_gizmo())
                    update_compacted_wipe_tower_clearance();
                if (c == GLGizmosManager::EType::Move ||
                    c == GLGizmosManager::EType::Scale ||
                    c == GLGizmosManager::EType::Rotate)
                    show_sinking_contours();
            }
        }
        else if (evt.LeftUp() &&
            m_gizmos.get_current_type() == GLGizmosManager::EType::Scale &&
            m_gizmos.get_current()->get_state() == GLGizmoBase::EState::On) {
            wxGetApp().obj_list()->selection_changed();
        }
 
        // A gizmo that acts on a click or a drag may not request a frame itself.
        if (!evt.Moving())
            m_dirty = true;
        return;
    }
 
    // A click on a center of mass marker shows its details instead of selecting.
    if (evt.LeftDown() && !mouse_in_layer_editing && m_center_of_mass.on_left_down(*this, pos.cast<double>())) {
        m_mouse.ignore_left_up = true;
        return;
    }
 
    bool any_gizmo_active = m_gizmos.get_current() != nullptr;
 
    std::map<MouseButton, MouseAction> button_mappings;
    button_mappings[MouseButton::Left] = static_cast<MouseAction>(std::atoi(wxGetApp().app_config->get("left_mouse_drag_action").c_str()));
    button_mappings[MouseButton::Middle] = static_cast<MouseAction>(std::atoi(wxGetApp().app_config->get("middle_mouse_drag_action").c_str()));
    button_mappings[MouseButton::Right] = static_cast<MouseAction>(std::atoi(wxGetApp().app_config->get("right_mouse_drag_action").c_str()));
 
    if (m_mouse.drag.move_requires_threshold && m_mouse.is_move_start_threshold_position_2D_defined() && m_mouse.is_move_threshold_met(pos)) {
        m_mouse.drag.move_requires_threshold = false;
        m_mouse.set_move_start_threshold_position_2D_as_invalid();
    }
 
    if (evt.ButtonDown() && wxWindow::FindFocus() != m_canvas)
        // Grab keyboard focus on any mouse click event.
        m_canvas->SetFocus();
 
    if (evt.Entering()) {
        // Set focus in order to remove it from sidebar fields and ensure hotkeys work
        if (m_canvas != nullptr) {
#if defined(__WXMSW__) && wxUSE_POPUPWIN
            // Don't steal focus when a popup window is active (e.g., search dropdown).
            // Stealing focus triggers MSWDismissUnfocusedPopup, closing the popup unexpectedly.
            if (!wxCurrentPopupWindow)
#endif
            {
                // Only set focus if the top level window of this canvas is active.
                auto p = dynamic_cast<wxWindow*>(evt.GetEventObject());
                while (p->GetParent())
                    p = p->GetParent();
                auto *top_level_wnd = dynamic_cast<wxTopLevelWindow*>(p);
                //Orca: Set focus so hotkeys like 'tab' work when a notification is shown.
                //But don't steal focus from text input controls.
                wxWindow* focused            = wxWindow::FindFocus();
                bool      focus_in_text_ctrl = dynamic_cast<wxTextCtrl*>(focused) != nullptr;
                if (top_level_wnd != nullptr && top_level_wnd->IsActive() && !focus_in_text_ctrl)
                    m_canvas->SetFocus();
            }
            m_mouse.position = pos.cast<double>();
            m_tooltip_enabled = false;
            // 1) forces a frame render to ensure that m_hover_volume_idxs is updated even when the user right clicks while
            // the context menu is shown, ensuring it to disappear if the mouse is outside any volume and to
            // change the volume hover state if any is under the mouse
            // 2) when switching between 3d view and preview the size of the canvas changes if the side panels are visible,
            // so forces a resize to avoid multiple renders with different sizes (seen as flickering)
            _refresh_if_shown_on_screen();
            m_tooltip_enabled = true;
        }
        m_mouse.set_start_position_2D_as_invalid();
    }
    else if (evt.Leaving()) {
        // to remove hover on objects when the mouse goes out of this canvas
        m_mouse.position = Vec2d(-1.0, -1.0);
        m_dirty = true;
    }
    else if (evt.LeftDClick()) {
        // switch to object panel if double click on object, otherwise switch to global panel if double click on background
        if (selected_object_idx >= 0)
            post_event(SimpleEvent(EVT_GLCANVAS_SWITCH_TO_OBJECT));
        else
            post_event(SimpleEvent(EVT_GLCANVAS_SWITCH_TO_GLOBAL));
    }
    else if (evt.LeftDown() || evt.RightDown() || evt.MiddleDown()) {
        // Orca: Retain the click position even if the first motion event crosses a surface edge.
        m_mouse.set_start_position_2D_as_invalid();
        m_mouse.drag.start_position_2D = pos;
 
        //BBS: add orient deactivate logic
        if (!m_gizmos.on_mouse(evt)) {
            if (_deactivate_arrange_menu() || _deactivate_orient_menu())
                return;
        }
 
        // If user pressed left or right button we first check whether this happened on a volume or not.
        m_layers_editing.state = LayersEditing::Unknown;
        if (mouse_in_layer_editing) {
            // A volume is selected and the mouse is inside the layer thickness bar.
            // Start editing the layer height.
            m_layers_editing.state = LayersEditing::Editing;
            _perform_layer_editing_action(&evt);
 
            if (!has_mouse_capture()) // ORCA keep tracking mouse position while drag active and cursor not in window bounds
                m_canvas->CaptureMouse();
        }
 
        else {
            // BBS: define Alt key to enable volume selection mode
            m_selection.set_volume_selection_mode(evt.AltDown() ? Selection::Volume : Selection::Instance);
            if (evt.LeftDown() && evt.ShiftDown() && m_picking_enabled && m_layers_editing.state != LayersEditing::Editing) {
                if (/*m_gizmos.get_current_type() != GLGizmosManager::SlaSupports
                    &&*/ m_gizmos.get_current_type() != GLGizmosManager::FdmSupports
                    && m_gizmos.get_current_type() != GLGizmosManager::Seam
                    && m_gizmos.get_current_type() != GLGizmosManager::Cut
                    && m_gizmos.get_current_type() != GLGizmosManager::MmSegmentation
                    && m_gizmos.get_current_type() != GLGizmosManager::FuzzySkin) {
                    m_rectangle_selection.start_dragging(m_mouse.position, evt.ShiftDown() ? GLSelectionRectangle::Select : GLSelectionRectangle::Deselect);
 
                    if (!has_mouse_capture())  // ORCA keep tracking mouse position while drag active and cursor not in window bounds
                        m_canvas->CaptureMouse();
 
                    m_dirty = true;
                }
            }
            else {
                // Select volume in this 3D canvas.
                // Don't deselect a volume if layer editing is enabled or any gizmo is active. We want the object to stay selected
                // during the scene manipulation.
 
                if (m_picking_enabled && (m_gizmos.is_allow_multi_select_parts_or_objects() || !evt.CmdDown()) && (!m_hover_volume_idxs.empty())) {
                    if (evt.LeftDown() && !m_hover_volume_idxs.empty()) {
                        int volume_idx = get_first_hover_volume_idx();
                        bool already_selected = m_selection.contains_volume(volume_idx);
                        bool ctrl_down = evt.CmdDown();
                        bool alt_down  = evt.AltDown();
                        Selection::IndicesList curr_idxs = m_selection.get_volume_idxs();
 
                        if (already_selected && ctrl_down)
                            m_selection.remove(volume_idx);
                        else if (alt_down && m_gizmos.is_allow_multi_select_parts_or_objects() && m_selection.get_mode() == Selection::Volume &&
                                 m_selection.get_object_idx() == m_volumes.volumes[volume_idx]->object_idx() &&
                                 m_selection.get_instance_idx() == m_volumes.volumes[volume_idx]->instance_idx()) {
                            // Alt+click on another part of the selected parts' instance adds it, and on a selected
                            // part removes it, unless it is the only one.
                            if (!already_selected)
                                m_selection.add_volumes(Selection::Volume, {(unsigned int) volume_idx}, false);
                            else if (curr_idxs.size() > 1)
                                m_selection.remove_volumes(Selection::Volume, {(unsigned int) volume_idx});
                        }
                        else if (alt_down) {
                            // Select just the clicked part, also when an object is selected.
                            Selection::EMode mode = Selection::Volume;
                            if (already_selected) {
                                std::vector<unsigned int> volume_idxs;
                                for (auto idx : curr_idxs) { volume_idxs.emplace_back(idx); }
                                m_selection.remove_volumes(mode, volume_idxs);
                            }
                            std::vector<unsigned int> add_volume_idxs;
                            add_volume_idxs.emplace_back(volume_idx);
                            m_selection.add_volumes(mode, add_volume_idxs, true);
                        }
                        else {
                            m_selection.add(volume_idx, !ctrl_down, true);
                            m_mouse.drag.move_requires_threshold = !already_selected;
                            if (already_selected)
                                m_mouse.set_move_start_threshold_position_2D_as_invalid();
                            else
                                m_mouse.drag.move_start_threshold_position_2D = pos;
                        }
 
                        // propagate event through callback
                        if (curr_idxs != m_selection.get_volume_idxs()) {
                            if (m_selection.is_empty())
                                m_gizmos.reset_all_states();
                            else
                                m_gizmos.refresh_on_off_state();
 
                            m_gizmos.update_data();
                            post_event(SimpleEvent(EVT_GLCANVAS_OBJECT_SELECT));
                            m_dirty = true;
                        }
                    }
                }
 
                if (!m_hover_volume_idxs.empty()) {
                    if (evt.LeftDown() && m_moving_enabled && m_mouse.drag.move_volume_idx == -1) {
                        // Only accept the initial position, if it is inside the volume bounding box.
                        int volume_idx = get_first_hover_volume_idx();
                        BoundingBoxf3 volume_bbox = m_volumes.volumes[volume_idx]->transformed_bounding_box();
                        volume_bbox.offset(1.0);
                        const bool is_cut_connector_selected = m_selection.is_any_connector();
                        const Vec3d scene_position = _mouse_to_3d(pos);
                        if ((!any_gizmo_active || !evt.CmdDown()) && volume_bbox.contains(scene_position) && !is_cut_connector_selected) {
                            m_volumes.volumes[volume_idx]->hover = GLVolume::HS_None;
                            // The dragging operation is initiated.
                            m_mouse.drag.move_volume_idx = volume_idx;
                            m_selection.setup_cache();
                            m_mouse.drag.start_position_3D = scene_position;
                            m_sequential_print_clearance_first_displacement = true;
                            m_moving = true;
 
                            if (!has_mouse_capture()) // ORCA keep tracking mouse position while drag active and cursor not in window bounds
                                m_canvas->CaptureMouse();
                        }
                    }
                }
            }
        }
    }
    else if (evt.Dragging() && evt.LeftIsDown() && m_mouse.drag.move_volume_idx != -1 && m_layers_editing.state == LayersEditing::Unknown) {
        if (m_canvas_type != ECanvasType::CanvasAssembleView) {
 
            if (!has_mouse_capture()) // ORCA keep tracking mouse position while drag active and cursor not in window bounds
                m_canvas->CaptureMouse();
 
            if (!m_mouse.drag.move_requires_threshold) {
                m_mouse.dragging = true;
                if (PartPlate *plate = wxGetApp().plater()->get_partplate_list().get_curr_plate())
                    plate->clear_exclusion_volume_intersections();
                Vec3d cur_pos = m_mouse.drag.start_position_3D;
                // we do not want to translate objects if the user just clicked on an object while pressing shift to remove it from the selection and then drag
                if (m_selection.contains_volume(get_first_hover_volume_idx())) {
                    const Camera& camera = wxGetApp().plater()->get_camera();
                    if (std::abs(camera.get_dir_forward()(2)) < EPSILON) {
                        // side view -> move selected volumes orthogonally to camera view direction
                        Linef3 ray = mouse_ray(pos);
                        Vec3d dir = ray.unit_vector();
                        // finds the intersection of the mouse ray with the plane parallel to the camera viewport and passing throught the starting position
                        // use ray-plane intersection see i.e. https://en.wikipedia.org/wiki/Line%E2%80%93plane_intersection algebric form
                        // in our case plane normal and ray direction are the same (orthogonal view)
                        // when moving to perspective camera the negative z unit axis of the camera needs to be transformed in world space and used as plane normal
                        Vec3d inters = ray.a + (m_mouse.drag.start_position_3D - ray.a).dot(dir) / dir.squaredNorm() * dir;
                        // vector from the starting position to the found intersection
                        Vec3d inters_vec = inters - m_mouse.drag.start_position_3D;
 
                        Vec3d camera_right = camera.get_dir_right();
                        Vec3d camera_up = camera.get_dir_up();
 
                        // finds projection of the vector along the camera axes
                        double projection_x = inters_vec.dot(camera_right);
                        double projection_z = inters_vec.dot(camera_up);
 
                        // apply offset
                        cur_pos = m_mouse.drag.start_position_3D + projection_x * camera_right + projection_z * camera_up;
                    }
                    else {
                        // Generic view
                        // Get new position at the same Z of the initial click point.
                        float z0 = 0.0f;
                        float z1 = 1.0f;
                        cur_pos = Linef3(_mouse_to_3d(pos, &z0), _mouse_to_3d(pos, &z1)).intersect_plane(m_mouse.drag.start_position_3D(2));
                    }
                }
 
                TransformationType trafo_type;
                trafo_type.set_relative();
                m_selection.translate(cur_pos - m_mouse.drag.start_position_3D, trafo_type);
                // Ghost transforms refresh from _render_imex_ghosts via the live GLVolume
                // lookup, so no explicit update call is needed here.
                if (current_printer_technology() == ptFFF) {
                    if (fff_print()->config().print_sequence == PrintSequence::ByObject)
                        update_sequential_clearance();
                    else
                        update_compacted_wipe_tower_clearance();
                }
                // BBS
                //wxGetApp().obj_manipul()->set_dirty();
                m_dirty = true;
            }
        }
    }
    else if (evt.Dragging() && evt.LeftIsDown() && m_picking_enabled && m_rectangle_selection.is_dragging()) {
        //BBS not in assemble view
        if (m_canvas_type != ECanvasType::CanvasAssembleView) {
 
            if (!has_mouse_capture()) // ORCA keep tracking mouse position while drag active and cursor not in window bounds
                m_canvas->CaptureMouse();
 
            m_rectangle_selection.dragging(pos.cast<double>());
            m_dirty = true;
        }
    }
    else if (evt.Dragging() || is_camera_rotate(evt, button_mappings) || is_camera_pan(evt, button_mappings)) {
        m_mouse.dragging = true;
 
        if (m_layers_editing.state != LayersEditing::Unknown && layer_editing_object_idx != -1) {
            if (m_layers_editing.state == LayersEditing::Editing) {
                if (!has_mouse_capture()) // ORCA keep tracking mouse position while drag active and cursor not in window bounds
                    m_canvas->CaptureMouse();
 
                _perform_layer_editing_action(&evt);
                m_mouse.position = pos.cast<double>();
            }
        }
        // do not process the dragging if the left mouse was set down in another canvas
        else if (is_camera_rotate(evt, button_mappings)) {
            // Orca: Rotation and panning use different drag coordinates and cached anchors.
            // Clear the pan state before processing rotation or switching buttons mid-drag.
            m_mouse.set_start_position_2D_as_invalid();
 
            if (!has_mouse_capture()) // ORCA keep tracking mouse position while drag active and cursor not in window bounds
                m_canvas->CaptureMouse();
 
            // Orca: Sphere rotation for painting view
            // if dragging over blank area with left button or other button mapped to rotate, then rotate
            bool middle_or_right_button_used_as_rotate = (evt.MiddleIsDown() && button_mappings[MouseButton::Middle] == MouseAction::Rotation) ||
                                                         (evt.RightIsDown() && button_mappings[MouseButton::Right] == MouseAction::Rotation);         
            if ((any_gizmo_active || middle_or_right_button_used_as_rotate || m_hover_volume_idxs.empty()) &&
                m_mouse.is_start_position_3D_defined()) {
                Camera& camera = wxGetApp().plater()->get_camera();
                auto mult_pref = wxGetApp().app_config->get("camera_orbit_mult");
                const double mult = mult_pref.empty() ? 1.0 : std::stod(mult_pref);
                const Vec3d rot = (Vec3d(pos.x(), pos.y(), 0.) - m_mouse.drag.start_position_3D) * (PI * TRACKBALLSIZE / 180.) * mult;
                if (this->m_canvas_type == ECanvasType::CanvasAssembleView || m_gizmos.get_current_type() == GLGizmosManager::FdmSupports ||
                    m_gizmos.get_current_type() == GLGizmosManager::Seam || m_gizmos.get_current_type() == GLGizmosManager::MmSegmentation ||
                    m_gizmos.get_current_type() == GLGizmosManager::FuzzySkin) {
                    // Orca: Reuse the centralized pivot policy for scene-oriented tools.
                    const std::optional<Vec3d> rotate_target = get_camera_orbit_target(ECameraNavigationType::Mouse);
                    if (rotate_target.has_value())
                        camera.rotate_on_sphere_with_target(rot.x(), rot.y(), false, *rotate_target);
                    else
                        camera.rotate_on_sphere(rot.x(), rot.y(), false);
                }
                else {
                    if (wxGetApp().app_config->get_bool("use_free_camera"))
                        // Virtual track ball (similar to the 3DConnexion mouse).
                        camera.rotate_local_around_target(Vec3d(rot.y(), rot.x(), 0.));
                    else {
                        // Forces camera right vector to be parallel to XY plane in case it has been misaligned using the 3D mouse free rotation.
                        // It is cheaper to call this function right away instead of testing wxGetApp().plater()->get_mouse3d_controller().connected(),
                        // which checks an atomics (flushes CPU caches).
                        // See GH issue #3816.
                        bool rotate_limit = current_printer_technology() != ptSLA;
 
                        camera.recover_from_free_camera();
                        if (evt.ControlDown() || evt.CmdDown()) {
                            if ((m_rotation_center.x() == 0.f) && (m_rotation_center.y() == 0.f) && (m_rotation_center.z() == 0.f)) {
                                auto canvas_w = float(get_canvas_size().get_width());
                                auto canvas_h = float(get_canvas_size().get_height());
                                Point screen_center(canvas_w/2, canvas_h/2);
                                m_rotation_center = _mouse_to_3d(screen_center);
                                m_rotation_center(2) = 0.f;
                            }
                            camera.rotate_on_sphere_with_target(rot.x(), rot.y(), rotate_limit, m_rotation_center);
                        } else {
                            // Orca: Keep regular mouse orbit and perspective-pan fallback centered
                            // on the same selection, active-plate, or scene reference.
                            const std::optional<Vec3d> rotate_target = get_camera_orbit_target(ECameraNavigationType::Mouse);
                            if (rotate_target.has_value())
                                camera.rotate_on_sphere_with_target(rot.x(), rot.y(), rotate_limit, *rotate_target);
                            else
                                camera.rotate_on_sphere(rot.x(), rot.y(), rotate_limit);
                        }
                    }
                }
 
                camera.auto_type(Camera::EType::Perspective);
                m_dirty = true;
                m_mouse.ignore_right_up = true;  // will be reset on button up event even if not right button is pressed
            }
 
            m_camera_movement = true;
            m_mouse.drag.start_position_3D = Vec3d((double)pos(0), (double)pos(1), 0.0);
        }
        else if (is_camera_pan(evt, button_mappings)) {
            // Orca: Pan uses screen coordinates and must not inherit the rotation start point.
            m_mouse.set_start_position_3D_as_invalid();
 
            if (!has_mouse_capture()) // ORCA keep tracking mouse position while drag active and cursor not in window bounds
                m_canvas->CaptureMouse();
 
            // if dragging with right button or if button functions swapped and dragging with left button over blank area then pan
            if (m_mouse.is_start_position_2D_defined()) {
                Camera& camera = wxGetApp().plater()->get_camera();
                if (this->m_canvas_type != ECanvasType::CanvasAssembleView) {
                    // Orca: Use a constrained camera when navigating the 3D scene with a regular mouse, if the free camera is not selected
                    if (!wxGetApp().app_config->get_bool("use_free_camera"))
                        // Forces camera right vector to be parallel to XY plane in case it has been misaligned using the 3D mouse free rotation.
                        // It is cheaper to call this function right away instead of testing wxGetApp().plater()->get_mouse3d_controller().connected(),
                        // which checks an atomics (flushes CPU caches).
                        // See GH issue #3816.
                        camera.recover_from_free_camera();
                }
 
                // Orca: Cache the surface under the initial click and apply every incremental
                // cursor delta at that depth, so perspective zoom and camera angle stay exact.
                const Vec2d screen_delta =
                    pos.cast<double>() - m_mouse.drag.start_position_2D.cast<double>();
                if (!m_mouse.drag.camera_pan_anchor.has_value())
                    m_mouse.drag.camera_pan_anchor = get_camera_pan_anchor(camera, ECameraNavigationType::Mouse,
                        m_mouse.drag.start_position_2D.cast<double>());
                pan_camera(camera, screen_delta, *m_mouse.drag.camera_pan_anchor);
                m_dirty = true;
                m_mouse.ignore_right_up = true;  // will be reset on button up event even if not right button is pressed
            }
 
            m_camera_movement = true;
            m_mouse.drag.start_position_2D = pos;
        }
    }
    else if ((evt.LeftUp() || evt.MiddleUp() || evt.RightUp()) ||
               (m_camera_movement && !is_camera_rotate(evt, button_mappings) && !is_camera_pan(evt, button_mappings))) {
        m_mouse.position = pos.cast<double>();
 
        // Check if the button that was released is mapped to rotation
        if ((evt.LeftUp() && button_mappings[MouseButton::Left] == MouseAction::Rotation) ||
            (evt.MiddleUp() && button_mappings[MouseButton::Middle] == MouseAction::Rotation) ||
            (evt.RightUp() && button_mappings[MouseButton::Right] == MouseAction::Rotation)) {
            m_rotation_center(0) = m_rotation_center(1) = m_rotation_center(2) = 0.f;
        }
 
        if (m_layers_editing.state != LayersEditing::Unknown) {
            m_layers_editing.state = LayersEditing::Unknown;
            _stop_timer();
            m_layers_editing.accept_changes(*this);
        }
        else if (m_mouse.drag.move_volume_idx != -1 && m_mouse.dragging) {
            do_move(L("Move object"));
            // BBS
            //wxGetApp().obj_manipul()->set_dirty();
            // Let the plater know that the dragging finished, so a delayed refresh
            // of the scene with the background processing data should be performed.
            post_event(SimpleEvent(EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED));
        }
        else if (evt.LeftUp() && m_picking_enabled && m_rectangle_selection.is_dragging() && m_layers_editing.state != LayersEditing::Editing) {
            //BBS: don't use alt as de-select
            //if (evt.ShiftDown() || evt.AltDown())
            if (evt.ShiftDown())
                _update_selection_from_hover();
 
            m_rectangle_selection.stop_dragging();
        }
        else if (evt.LeftUp() && !m_mouse.dragging && m_hover_ghost_head >= 0) {
            // IMEX ghost click: dispatch to Plater (filament picker). The else-if chain
            // already prevents deselect/plate-select from firing on the same event; we
            // fall through to mouse_up_cleanup() below so mouse capture and drag state
            // get reset like every other branch in this chain.
            wxGetApp().plater()->on_imex_ghost_click(m_hover_ghost_head);
        }
        else if (evt.LeftUp() && !m_mouse.ignore_left_up && !m_mouse.dragging && m_hover_volume_idxs.empty() && m_hover_plate_idxs.empty() && !is_layers_editing_enabled()) {
            // deselect and propagate event through callback
            if (!evt.ShiftDown() && (!any_gizmo_active || !evt.CmdDown()) && m_picking_enabled)
                deselect_all();
        }
        //BBS Select plate in this 3D canvas.
        // The left up may come from an ImGui window (e.g. a drag started on the gizmo floating window and released over the bed),
        // in which case it must not be treated as a click on the plate, otherwise the gizmo would be closed (see deselect_all below).
        else if (evt.LeftUp() && !m_mouse.ignore_left_up && !m_mouse.dragging && m_picking_enabled && !m_hover_plate_idxs.empty() && (m_canvas_type == CanvasView3D) && !is_layers_editing_enabled())
        {
                int hover_idx = m_hover_plate_idxs.front();
                wxGetApp().plater()->select_plate_by_hover_id(hover_idx);
                //wxGetApp().plater()->get_partplate_list().select_plate_view();
                //deselect all the objects
                if (m_gizmos.get_current_type() != GLGizmosManager::MeshBoolean && m_hover_volume_idxs.empty())
                    deselect_all();
        }
        else if (evt.RightUp() && !is_layers_editing_enabled()) {
            // forces a frame render to ensure that m_hover_volume_idxs is updated even when the user right clicks while
            // the context menu is already shown
            render();
            if (!m_hover_volume_idxs.empty()) {
                // if right clicking on volume, propagate event through callback (shows context menu)
                int volume_idx = get_first_hover_volume_idx();
                if (!m_volumes.volumes[volume_idx]->is_wipe_tower // no context menu for the wipe tower
                    /*&& m_gizmos.get_current_type() != GLGizmosManager::SlaSupports*/)  // disable context menu when the gizmo is open
                {
                    // forces the selection of the volume
                    /* m_selection.add(volume_idx); // #et_FIXME_if_needed
                     * To avoid extra "Add-Selection" snapshots,
                     * call add() with check_for_already_contained=true
                     * */
                    m_selection.add(volume_idx, true, true);
                    m_gizmos.refresh_on_off_state();
                    post_event(SimpleEvent(EVT_GLCANVAS_OBJECT_SELECT));
                    m_gizmos.update_data();
                    // BBS
                    //wxGetApp().obj_manipul()->set_dirty();
                    // forces a frame render to update the view before the context menu is shown
                    render();
                }
            }
 
            //BBS change plate selection
            bool plate_icon_popup_shown = false;
            if (!m_hover_plate_idxs.empty() && (m_canvas_type == CanvasView3D) && !m_mouse.dragging) {
                int hover_idx = m_hover_plate_idxs.front();
                plate_icon_popup_shown = (wxGetApp().plater()->select_plate_by_hover_id(hover_idx, true) == 1);
                if (m_hover_volume_idxs.empty())
                    deselect_all();
                render();
            }
 
            //ORCA allow right click on empty space while an object selected
            if (m_hover_plate_idxs.empty() && m_hover_volume_idxs.empty() && (m_canvas_type == CanvasView3D) && !m_mouse.dragging) {
                deselect_all();
                render();
            }
 
            Vec2d logical_pos = pos.cast<double>();
#if ENABLE_RETINA_GL
            const float factor = m_retina_helper->get_scale_factor();
            logical_pos = logical_pos.cwiseQuotient(Vec2d(factor, factor));
#endif // ENABLE_RETINA_GL
 
            if (!m_mouse.ignore_right_up && m_gizmos.get_current_type() == GLGizmosManager::EType::Undefined) {
                //BBS post right click event
                if (!m_hover_plate_idxs.empty() && !plate_icon_popup_shown) {
                    post_event(RBtnPlateEvent(EVT_GLCANVAS_PLATE_RIGHT_CLICK, { logical_pos, m_hover_plate_idxs.front() }));
                }
                else if (!plate_icon_popup_shown) {
                    // do not post the event if the user is panning the scene
                    // or if right click was done over the wipe tower
                    bool post_right_click_event = m_hover_volume_idxs.empty() || !m_volumes.volumes[get_first_hover_volume_idx()]->is_wipe_tower;
                    if (post_right_click_event)
                        post_event(RBtnEvent(EVT_GLCANVAS_RIGHT_CLICK, { logical_pos, m_hover_volume_idxs.empty() }));
                }
            }
        }
 
        mouse_up_cleanup();
    }
    else if (evt.Moving()) {
        m_mouse.position = pos.cast<double>();
 
        // updates gizmos overlay
        if (m_selection.is_empty())
            m_gizmos.reset_all_states();
 
        _set_overlay_as_dirty();
    }
    else
        evt.Skip();
 
    // Detection of doubleclick on text to open emboss edit window
    auto type = m_gizmos.get_current_type();
    if (evt.LeftDClick() && !m_hover_volume_idxs.empty() &&
        (type == GLGizmosManager::EType::Undefined ||
         type == GLGizmosManager::EType::Move ||
         type == GLGizmosManager::EType::Rotate ||
         type == GLGizmosManager::EType::Scale ||
         type == GLGizmosManager::EType::Emboss ||
         type == GLGizmosManager::EType::Svg) ) {
        for (int hover_volume_id : m_hover_volume_idxs) {
            const GLVolume &hover_gl_volume = *m_volumes.volumes[hover_volume_id];
            int object_idx = hover_gl_volume.object_idx();
            if (object_idx < 0 || static_cast<size_t>(object_idx) >= m_model->objects.size()) continue;
            const ModelObject* hover_object = m_model->objects[object_idx];
            int hover_volume_idx = hover_gl_volume.volume_idx();
            if (hover_volume_idx < 0 || static_cast<size_t>(hover_volume_idx) >= hover_object->volumes.size()) continue;
            const ModelVolume* hover_volume = hover_object->volumes[hover_volume_idx];
 
            if (hover_volume->text_configuration.has_value()) {
                m_selection.add_volumes(Selection::EMode::Volume, {(unsigned) hover_volume_id});
                if (type != GLGizmosManager::EType::Emboss)
                    m_gizmos.open_gizmo(GLGizmosManager::EType::Emboss);
                wxGetApp().obj_list()->update_selections();
                return;
            } else if (hover_volume->emboss_shape.has_value()) {
                m_selection.add_volumes(Selection::EMode::Volume, {(unsigned) hover_volume_id});
                if (type != GLGizmosManager::EType::Svg)
                    m_gizmos.open_gizmo(GLGizmosManager::EType::Svg);
                wxGetApp().obj_list()->update_selections();
                return;
            }
        }
    }
 
    if (m_moving)
        show_sinking_contours();
 
#ifdef __WXMSW__
  if (on_enter_workaround)
    m_mouse.position = Vec2d(-1., -1.);
#endif /* __WXMSW__ */
}

Referenced by bind_event_handlers(), Slic3r::GUI::anonymous_namespace{Plater.cpp}::emboss_svg(), on_mouse(), and unbind_event_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_mouse_wheel()

void Slic3r::GUI::GLCanvas3D::on_mouse_wheel ( wxMouseEvent & evt )

{
#ifdef WIN32
    // Try to filter out spurious mouse wheel events comming from 3D mouse.
    if (wxGetApp().plater()->get_mouse3d_controller().process_mouse_wheel())
        return;
#endif
 
    if (!m_initialized)
        return;
 
    // Ignore the wheel events if the middle button is pressed.
    if (evt.MiddleIsDown())
        return;
 
    m_alt_wheel_used |= evt.AltDown();
 
#if ENABLE_RETINA_GL
    const float scale = m_retina_helper->get_scale_factor();
    evt.SetX(evt.GetX() * scale);
    evt.SetY(evt.GetY() * scale);
#endif
 
    if (wxGetApp().imgui()->update_mouse_data(evt)) {
        if (m_canvas_type == CanvasPreview) {
            IMSlider* m_layers_slider = get_gcode_viewer().get_layers_slider();
            IMSlider* m_moves_slider = get_gcode_viewer().get_moves_slider();
            m_layers_slider->on_mouse_wheel(evt);
            m_moves_slider->on_mouse_wheel(evt);
        }
        render();
        m_dirty = true;
        return;
    }
 
#ifdef __WXMSW__
  // For some reason the Idle event is not being generated after the mouse scroll event in case of scrolling with the two fingers on the touch pad,
  // if the event is not allowed to be passed further.
    // evt.Skip() used to trigger the needed screen refresh, but it does no more. wxWakeUpIdle() seem to work now.
    wxWakeUpIdle();
#endif /* __WXMSW__ */
 
    // Performs layers editing updates, if enabled
    if (is_layers_editing_enabled()) {
        int object_idx_selected = m_selection.get_object_idx();
        if (object_idx_selected != -1) {
            // A volume is selected. Test, whether hovering over a layer thickness bar.
            if (m_layers_editing.bar_rect_contains(*this, (float)evt.GetX(), (float)evt.GetY())) {
                // Adjust the width of the selection.
                m_layers_editing.band_width = std::max(std::min(m_layers_editing.band_width * (1.0f + 0.1f * (float)evt.GetWheelRotation() / (float)evt.GetWheelDelta()), 10.0f), 1.5f);
                if (m_canvas != nullptr)
                    m_canvas->Refresh();
 
                return;
            }
        }
    }
 
    // Inform gizmos about the event so they have the opportunity to react.
    if (m_gizmos.on_mouse_wheel(evt))
        return;
 
    if (evt.AltDown()) {
        set_section_view_ratio(get_section_view_ratio() + (evt.GetWheelRotation() < 0 ? -0.01 : 0.01));
        return;
    }
 
    if (m_canvas_type == CanvasAssembleView && evt.CmdDown()) {
        float rotation = (float)evt.GetWheelRotation() / (float)evt.GetWheelDelta();
        m_explosion_ratio = rotation < 0.f
            ? std::max(1., m_explosion_ratio - 0.01)
            : std::min(3., m_explosion_ratio + 0.01);
        if (m_explosion_ratio != GLVolume::explosion_ratio) {
            for (GLVolume* volume : m_volumes.volumes) {
                volume->set_bounding_boxes_as_dirty();
            }
            GLVolume::explosion_ratio = m_explosion_ratio;
        }
        return;
    }
    // Calculate the zoom delta and apply it to the current zoom factor
    double direction_factor = wxGetApp().app_config->get_bool("reverse_mouse_wheel_zoom") ? -1.0 : 1.0;
    auto delta = direction_factor * (double)evt.GetWheelRotation() / (double)evt.GetWheelDelta();
    bool zoom_to_mouse = wxGetApp().app_config->get("zoom_to_mouse") == "true";
    if (!zoom_to_mouse) {// zoom to center
        _update_camera_zoom(delta);
    }
    else {
        auto cnv_size = get_canvas_size();
        float z{0.f};
        auto screen_center_3d_pos = _mouse_to_3d({ cnv_size.get_width() * 0.5, cnv_size.get_height() * 0.5 }, &z);
        auto mouse_3d_pos = _mouse_to_3d({evt.GetX(), evt.GetY()}, &z);
        Vec3d displacement = mouse_3d_pos - screen_center_3d_pos;
 
        wxGetApp().plater()->get_camera().translate(displacement);
        auto origin_zoom = wxGetApp().plater()->get_camera().get_zoom();
        _update_camera_zoom(delta);
        auto new_zoom = wxGetApp().plater()->get_camera().get_zoom();
        wxGetApp().plater()->get_camera().translate((-displacement) / (new_zoom / origin_zoom));
    }
}

References _mouse_to_3d(), _update_camera_zoom(), CanvasAssembleView, CanvasPreview, Slic3r::GLVolume::explosion_ratio, get_canvas_size(), get_gcode_viewer(), Slic3r::GUI::GCodeViewer::get_layers_slider(), Slic3r::GUI::GCodeViewer::get_moves_slider(), get_section_view_ratio(), is_layers_editing_enabled(), m_alt_wheel_used, m_canvas, m_canvas_type, m_dirty, m_explosion_ratio, m_gizmos, m_initialized, m_layers_editing, m_selection, m_volumes, Slic3r::GUI::IMSlider::on_mouse_wheel(), Slic3r::GUI::plater(), Slic3r::GUI::process_mouse_wheel(), render(), scale(), Slic3r::GLVolume::set_bounding_boxes_as_dirty(), set_section_view_ratio(), and Slic3r::GUI::wxMouseEvent.

Referenced by bind_event_handlers(), and unbind_event_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_paint()

void Slic3r::GUI::GLCanvas3D::on_paint ( wxPaintEvent & evt )

{
    m_presented_signature.reset();
    if (m_initialized) {
#ifdef __WXMSW__
        // Idle events are not dispatched during the Windows resize modal loop,
        // so render immediately to avoid blank frames.
        _refresh_if_shown_on_screen();
        m_dirty = false;
#else
        m_dirty = true;
#endif
    } else {
        // Call render directly, so it gets initialized immediately, not from On Idle handler.
        this->render();
    }
}

References _refresh_if_shown_on_screen(), m_dirty, m_initialized, m_presented_signature, and render().

Referenced by bind_event_handlers(), and unbind_event_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_render_timer()

void Slic3r::GUI::GLCanvas3D::on_render_timer ( wxTimerEvent & evt )

{
    // no need to wake up idle
    // right after this event, idle event is fired
    // m_dirty = true;
    // wxWakeUpIdle();
}

Referenced by bind_event_handlers(), and unbind_event_handlers().

Here is the caller graph for this function:

◆ on_set_color_timer()

void Slic3r::GUI::GLCanvas3D::on_set_color_timer ( wxTimerEvent & evt )

{
    auto obj_list = wxGetApp().obj_list();
    if (m_gizmos.get_current_type() != GLGizmosManager::MmSegmentation)
        obj_list->set_extruder_for_selected_items(1);
    m_timer_set_color.Stop();
}

References m_gizmos, m_timer_set_color, Slic3r::GUI::GLGizmosManager::MmSegmentation, and Slic3r::GUI::obj_list().

Referenced by GLCanvas3D().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_set_focus()

void Slic3r::GUI::GLCanvas3D::on_set_focus ( wxFocusEvent & evt )

{
#ifdef __APPLE__
    // The focused canvas is the one whose view takes input-method text (see ImGuiWrapper::end_frame()).
    ImGui::GetIO().ImeWindowHandle = m_canvas->GetHandle();
#endif
    m_tooltip_enabled = false;
    _refresh_if_shown_on_screen();
    m_tooltip_enabled = true;
    m_is_touchpad_navigation = wxGetApp().app_config->get_bool("camera_navigation_style");
}

References _refresh_if_shown_on_screen(), m_canvas, m_is_touchpad_navigation, and m_tooltip_enabled.

Referenced by bind_event_handlers(), and unbind_event_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_size()

void Slic3r::GUI::GLCanvas3D::on_size ( wxSizeEvent & evt )

inline

1274{ m_dirty = true; }

References m_dirty.

Referenced by bind_event_handlers(), and unbind_event_handlers().

Here is the caller graph for this function:

◆ on_timer()

void Slic3r::GUI::GLCanvas3D::on_timer ( wxTimerEvent & evt )

{
    if (m_layers_editing.state == LayersEditing::Editing)
        _perform_layer_editing_action();
}

References _perform_layer_editing_action(), Slic3r::GUI::GLCanvas3D::LayersEditing::Editing, and m_layers_editing.

Referenced by bind_event_handlers(), and unbind_event_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ plate_scene_bounding_box()

BoundingBoxf3 Slic3r::GUI::GLCanvas3D::plate_scene_bounding_box ( int plate_idx ) const

{
    PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_plate(plate_idx);
 
    BoundingBoxf3 bb = plate->get_bounding_box(true);
    if (m_config != nullptr) {
        double h = m_config->opt_float("printable_height");
        bb.min(2) = std::min(bb.min(2), -h);
        bb.max(2) = std::max(bb.max(2), h);
    }
 
    return bb;
}

References Slic3r::GUI::PartPlate::get_bounding_box(), m_config, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, and Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min.

Here is the call graph for this function:

◆ plates_count_changed()

void Slic3r::GUI::GLCanvas3D::plates_count_changed ( )

{
    refresh_camera_scene_box();
    m_dirty = true;
}

References m_dirty, and refresh_camera_scene_box().

Here is the call graph for this function:

◆ post_event()

void Slic3r::GUI::GLCanvas3D::post_event ( wxEvent && event )

{
    event.SetEventObject(m_canvas);
    wxPostEvent(m_canvas, event);
}

References m_canvas.

Referenced by _render_frame(), _render_gcode_overlay(), _update_selection_from_hover(), Slic3r::GUI::GLCanvas3D::LayersEditing::accept_changes(), Slic3r::GUI::GLCanvas3D::LayersEditing::adaptive_layer_height_profile(), Slic3r::GUI::ObjectList::del_info_item(), deselect_all(), do_mirror(), do_move(), do_rotate(), do_scale(), finish_selection_edit(), handle_shortcut(), on_mouse(), reload_scene(), Slic3r::GUI::GLCanvas3D::LayersEditing::reset_layer_height_profile(), and Slic3r::GUI::GLCanvas3D::LayersEditing::smooth_layer_height_profile().

Here is the caller graph for this function:

◆ refresh_camera_scene_box()

void Slic3r::GUI::GLCanvas3D::refresh_camera_scene_box ( )

{
    wxGetApp().plater()->get_camera().set_scene_box(scene_bounding_box());
}

References scene_bounding_box().

Referenced by bed_shape_changed(), finish_selection_edit(), plates_count_changed(), and reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ release_held_modifiers()

void Slic3r::GUI::GLCanvas3D::release_held_modifiers ( )

{
    for (const int key : { WXK_SHIFT, WXK_CONTROL, WXK_ALT }) {
        if (s_keys_down.count(key) == 0)
            continue;
        wxKeyEvent release(wxEVT_KEY_UP);
        release.m_keyCode = key;
        on_key(release);
    }
}

References on_key(), and Slic3r::GUI::s_keys_down.

Referenced by bind_event_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reload_scene()

void Slic3r::GUI::GLCanvas3D::reload_scene	(	bool	refresh_immediately,
		bool	force_full_scene_refresh = false )

print->is_step_done(psWipeTower)

{
    if (m_canvas == nullptr || m_config == nullptr || m_model == nullptr)
        return;
 
    if (!m_initialized || !_set_current()) {
        m_reload_delayed = true;
        set_as_dirty();
        return;
    }
 
    m_hover_volume_idxs.clear();
 
    struct ModelVolumeState {
        ModelVolumeState(const GLVolume* volume) :
            model_volume(nullptr), geometry_id(volume->geometry_id), volume_idx(-1) {}
        ModelVolumeState(const ModelVolume* model_volume, const ObjectID& instance_id, const GLVolume::CompositeID& composite_id) :
            model_volume(model_volume), geometry_id(std::make_pair(model_volume->id().id, instance_id.id)), composite_id(composite_id), volume_idx(-1) {}
        ModelVolumeState(const ObjectID& volume_id, const ObjectID& instance_id) :
            model_volume(nullptr), geometry_id(std::make_pair(volume_id.id, instance_id.id)), volume_idx(-1) {}
        bool new_geometry() const { return this->volume_idx == size_t(-1); }
        const ModelVolume* model_volume;
        // ObjectID of ModelVolume + ObjectID of ModelInstance
        // or timestamp of an SLAPrintObjectStep + ObjectID of ModelInstance
        std::pair<size_t, size_t>   geometry_id;
        GLVolume::CompositeID       composite_id;
        // Volume index in the new GLVolume vector.
        size_t                      volume_idx;
    };
    std::vector<ModelVolumeState> model_volume_state;
    std::vector<ModelVolumeState> aux_volume_state;
 
    struct GLVolumeState {
        GLVolumeState() :
            volume_idx(size_t(-1)) {}
        GLVolumeState(const GLVolume* volume, unsigned int volume_idx) :
            composite_id(volume->composite_id), volume_idx(volume_idx) {}
        GLVolumeState(const GLVolume::CompositeID &composite_id) :
            composite_id(composite_id), volume_idx(size_t(-1)) {}
 
        GLVolume::CompositeID       composite_id;
        // Volume index in the old GLVolume vector.
        size_t                      volume_idx;
    };
 
    // SLA steps to pull the preview meshes for.
  typedef std::array<SLAPrintObjectStep, 3> SLASteps;
    SLASteps sla_steps = { slaposDrillHoles, slaposSupportTree, slaposPad };
    struct SLASupportState {
        std::array<PrintStateBase::StateWithTimeStamp, std::tuple_size<SLASteps>::value> step;
    };
    // State of the sla_steps for all SLAPrintObjects.
    std::vector<SLASupportState>   sla_support_state;
 
    std::vector<size_t> instance_ids_selected;
    std::vector<size_t> map_glvolume_old_to_new(m_volumes.volumes.size(), size_t(-1));
    std::vector<GLVolumeState> deleted_volumes;
    // BBS
    std::vector<GLVolumeState> deleted_wipe_towers;
    std::vector<GLVolume*> glvolumes_new;
    glvolumes_new.reserve(m_volumes.volumes.size());
    auto model_volume_state_lower = [](const ModelVolumeState& m1, const ModelVolumeState& m2) { return m1.geometry_id < m2.geometry_id; };
 
    m_reload_delayed = !m_canvas->IsShown() && !refresh_immediately && !force_full_scene_refresh;
    if (m_reload_delayed) {
        set_as_dirty();
        return;
    }
 
    PrinterTechnology printer_technology = current_printer_technology();
 
    // BBS: support wipe tower for multi-plates
    PartPlateList& ppl = wxGetApp().plater()->get_partplate_list();
    int n_plates = ppl.get_plate_count();
    std::vector<int> volume_idxs_wipe_tower_old(n_plates, -1);
 
    // Release invalidated volumes to conserve GPU memory in case of delayed refresh (see m_reload_delayed).
    // First initialize model_volumes_new_sorted & model_instances_new_sorted.
    for (int object_idx = 0; object_idx < (int)m_model->objects.size(); ++object_idx) {
        const ModelObject* model_object = m_model->objects[object_idx];
        for (int instance_idx = 0; instance_idx < (int)model_object->instances.size(); ++instance_idx) {
            const ModelInstance* model_instance = model_object->instances[instance_idx];
            for (int volume_idx = 0; volume_idx < (int)model_object->volumes.size(); ++volume_idx) {
                const ModelVolume* model_volume = model_object->volumes[volume_idx];
                if (m_canvas_type == ECanvasType::CanvasAssembleView) {
                    if (model_volume->is_model_part())
                        model_volume_state.emplace_back(model_volume, model_instance->id(), GLVolume::CompositeID(object_idx, volume_idx, instance_idx));
                }
                else {
                    model_volume_state.emplace_back(model_volume, model_instance->id(), GLVolume::CompositeID(object_idx, volume_idx, instance_idx));
                }
            }
        }
    }
    if (printer_technology == ptSLA) {
        const SLAPrint* sla_print = this->sla_print();
#ifndef NDEBUG
        // Verify that the SLAPrint object is synchronized with m_model.
        check_model_ids_equal(*m_model, sla_print->model());
#endif /* NDEBUG */
        sla_support_state.reserve(sla_print->objects().size());
        for (const SLAPrintObject* print_object : sla_print->objects()) {
            SLASupportState state;
            for (size_t istep = 0; istep < sla_steps.size(); ++istep) {
                state.step[istep] = print_object->step_state_with_timestamp(sla_steps[istep]);
                if (state.step[istep].state == PrintStateBase::DONE) {
                    if (!print_object->has_mesh(sla_steps[istep]))
                        // Consider the DONE step without a valid mesh as invalid for the purpose
                        // of mesh visualization.
                        state.step[istep].state = PrintStateBase::INVALID;
                    else if (sla_steps[istep] != slaposDrillHoles)
                        for (const ModelInstance* model_instance : print_object->model_object()->instances)
                            // Only the instances, which are currently printable, will have the SLA support structures kept.
                            // The instances outside the print bed will have the GLVolumes of their support structures released.
                            if (model_instance->is_printable())
                                aux_volume_state.emplace_back(state.step[istep].timestamp, model_instance->id());
                }
            }
            sla_support_state.emplace_back(state);
        }
    }
    std::sort(model_volume_state.begin(), model_volume_state.end(), model_volume_state_lower);
    std::sort(aux_volume_state.begin(), aux_volume_state.end(), model_volume_state_lower);
 
    // BBS: normalize painting data with current filament count
    for (unsigned int obj_idx = 0; obj_idx < (unsigned int)m_model->objects.size(); ++obj_idx) {
        const ModelObject& model_object = *m_model->objects[obj_idx];
        for (int volume_idx = 0; volume_idx < (int)model_object.volumes.size(); ++volume_idx) {
            ModelVolume& model_volume = *model_object.volumes[volume_idx];
            if (!model_volume.is_model_part())
                continue;
 
            unsigned int filaments_count = (unsigned int)dynamic_cast<const ConfigOptionStrings*>(m_config->option("filament_colour"))->values.size();
            model_volume.update_extruder_count(filaments_count);
        }
    }
 
    // Release all ModelVolume based GLVolumes not found in the current Model. Find the GLVolume of a hollowed mesh.
    for (size_t volume_id = 0; volume_id < m_volumes.volumes.size(); ++volume_id) {
        GLVolume* volume = m_volumes.volumes[volume_id];
        ModelVolumeState  key(volume);
        ModelVolumeState* mvs = nullptr;
        if (volume->volume_idx() < 0) {
            auto it = std::lower_bound(aux_volume_state.begin(), aux_volume_state.end(), key, model_volume_state_lower);
            if (it != aux_volume_state.end() && it->geometry_id == key.geometry_id)
                // This can be an SLA support structure that should not be rendered (in case someone used undo
                // to revert to before it was generated). We only reuse the volume if that's not the case.
                if (m_model->objects[volume->composite_id.object_id]->sla_points_status != sla::PointsStatus::NoPoints)
                    mvs = &(*it);
        }
        else {
            auto it = std::lower_bound(model_volume_state.begin(), model_volume_state.end(), key, model_volume_state_lower);
            if (it != model_volume_state.end() && it->geometry_id == key.geometry_id)
                mvs = &(*it);
        }
        // Emplace instance ID of the volume. Both the aux volumes and model volumes share the same instance ID.
        // The wipe tower has its own wipe_tower_instance_id().
        if (m_selection.contains_volume(volume_id)) {
            if (m_canvas_type == ECanvasType::CanvasAssembleView) {
                if (!volume->is_modifier)
                    instance_ids_selected.emplace_back(volume->geometry_id.second);
            }
            else {
                instance_ids_selected.emplace_back(volume->geometry_id.second);
            }
        }
        if (mvs == nullptr || force_full_scene_refresh) {
            // This GLVolume will be released.
            if (volume->is_wipe_tower) {
                // There is only one wipe tower.
                //assert(volume_idx_wipe_tower_old == -1);
                int plate_id = volume->composite_id.object_id - 1000;
                if (plate_id < n_plates)
                    volume_idxs_wipe_tower_old[plate_id] = (int)volume_id;
            }
            if (!m_reload_delayed) {
                deleted_volumes.emplace_back(volume, volume_id);
                // BBS
                if (volume->is_wipe_tower)
                    deleted_wipe_towers.emplace_back(volume, volume_id);
                delete volume;
            }
        }
        else {
            // This GLVolume will be reused.
            volume->set_sla_shift_z(0.0);
            map_glvolume_old_to_new[volume_id] = glvolumes_new.size();
            mvs->volume_idx = glvolumes_new.size();
            glvolumes_new.emplace_back(volume);
            // Update color of the volume based on the current extruder.
            if (mvs->model_volume != nullptr) {
                int extruder_id = mvs->model_volume->extruder_id();
                if (extruder_id != -1)
                    volume->extruder_id = extruder_id;
 
                volume->is_modifier = !mvs->model_volume->is_model_part();
                volume->set_color(color_from_model_volume(*mvs->model_volume));
 
                // updates volumes transformations
                if (m_canvas_type != ECanvasType::CanvasAssembleView) {
                    volume->set_instance_transformation(mvs->model_volume->get_object()->instances[mvs->composite_id.instance_id]->get_transformation());
                    volume->set_volume_transformation(mvs->model_volume->get_transformation());
                    // updates volumes convex hull
                    if (mvs->model_volume->is_model_part() && ! volume->convex_hull())
                        // Model volume was likely changed from modifier or support blocker / enforcer to a model part.
                        // Only model parts require convex hulls.
                        volume->set_convex_hull(mvs->model_volume->get_convex_hull_shared_ptr());
                    volume->set_offset_to_assembly(Vec3d(0, 0, 0));
                }
                else {
                    volume->set_instance_transformation(mvs->model_volume->get_object()->instances[mvs->composite_id.instance_id]->get_assemble_transformation());
                    volume->set_volume_transformation(mvs->model_volume->get_transformation());
                    // updates volumes convex hull
                    if (mvs->model_volume->is_model_part() && ! volume->convex_hull())
                        // Model volume was likely changed from modifier or support blocker / enforcer to a model part.
                        // Only model parts require convex hulls.
                        volume->set_convex_hull(mvs->model_volume->get_convex_hull_shared_ptr());
                    volume->set_offset_to_assembly(mvs->model_volume->get_object()->instances[mvs->composite_id.instance_id]->get_offset_to_assembly());
                }
            }
        }
    }
    sort_remove_duplicates(instance_ids_selected);
    auto deleted_volumes_lower = [](const GLVolumeState &v1, const GLVolumeState &v2) { return v1.composite_id < v2.composite_id; };
    std::sort(deleted_volumes.begin(), deleted_volumes.end(), deleted_volumes_lower);
 
    //BBS clean hover_volume_idxs
    m_hover_volume_idxs.clear();
 
    // BBS: do not check wipe tower changes
    bool update_object_list = false;
    if (deleted_volumes.size() != deleted_wipe_towers.size())
        update_object_list = true;
 
    if (m_volumes.volumes != glvolumes_new && !update_object_list) {
        int vol_idx = 0;
        for (; vol_idx < std::min(m_volumes.volumes.size(), glvolumes_new.size()); vol_idx++) {
            if (m_volumes.volumes[vol_idx] != glvolumes_new[vol_idx]) {
                update_object_list = true;
                break;
            }
        }
        for (int temp_idx = vol_idx; temp_idx < m_volumes.volumes.size() && !update_object_list; temp_idx++) {
            // Volumes in m_volumes might not exist anymore, so we cannot
            // directly check if they are is_wipe_towers, for which we do
            // not want to update the object list.  Instead, we do a kind of
            // slow thing of seeing if they were in the deleted list, and if
            // so, if they were a wipe tower.
            bool was_deleted_wipe_tower = false;
            for (int del_idx = 0; del_idx < deleted_wipe_towers.size(); del_idx++) {
                if (deleted_wipe_towers[del_idx].volume_idx == temp_idx) {
                    was_deleted_wipe_tower = true;
                    break;
                }
            }
            if (!was_deleted_wipe_tower) {
                update_object_list = true;
            }
        }
        for (int temp_idx = vol_idx; temp_idx < glvolumes_new.size() && !update_object_list; temp_idx++) {
            if (!glvolumes_new[temp_idx]->is_wipe_tower)
                update_object_list = true;
        }
    }
    m_volumes.volumes = std::move(glvolumes_new);
    for (unsigned int obj_idx = 0; obj_idx < (unsigned int)m_model->objects.size(); ++ obj_idx) {
        const ModelObject &model_object = *m_model->objects[obj_idx];
        for (int volume_idx = 0; volume_idx < (int)model_object.volumes.size(); ++ volume_idx) {
      const ModelVolume &model_volume = *model_object.volumes[volume_idx];
            if (m_canvas_type == ECanvasType::CanvasAssembleView && !model_volume.is_model_part())
                continue;
            for (int instance_idx = 0; instance_idx < (int)model_object.instances.size(); ++ instance_idx) {
        const ModelInstance &model_instance = *model_object.instances[instance_idx];
        ModelVolumeState key(model_volume.id(), model_instance.id());
        auto it = std::lower_bound(model_volume_state.begin(), model_volume_state.end(), key, model_volume_state_lower);
        assert(it != model_volume_state.end() && it->geometry_id == key.geometry_id);
                if (it->new_geometry()) {
                    // New volume.
                    auto it_old_volume = std::lower_bound(deleted_volumes.begin(), deleted_volumes.end(), GLVolumeState(it->composite_id), deleted_volumes_lower);
                    if (it_old_volume != deleted_volumes.end() && it_old_volume->composite_id == it->composite_id)
                        // If a volume changed its ObjectID, but it reuses a GLVolume's CompositeID, maintain its selection.
                        map_glvolume_old_to_new[it_old_volume->volume_idx] = m_volumes.volumes.size();
                    // Note the index of the loaded volume, so that we can reload the main model GLVolume with the hollowed mesh
                    // later in this function.
                    it->volume_idx = m_volumes.volumes.size();
                    m_volumes.load_object_volume(&model_object, obj_idx, volume_idx, instance_idx, m_color_by, m_initialized, m_canvas_type == ECanvasType::CanvasAssembleView);
                    m_volumes.volumes.back()->geometry_id = key.geometry_id;
                    update_object_list = true;
                } else {
          // Recycling an old GLVolume.
          GLVolume &existing_volume = *m_volumes.volumes[it->volume_idx];
                    assert(existing_volume.geometry_id == key.geometry_id);
          // Update the Object/Volume/Instance indices into the current Model.
          if (existing_volume.composite_id != it->composite_id) {
            existing_volume.composite_id = it->composite_id;
            update_object_list = true;
          }
                }
            }
        }
    }
    if (printer_technology == ptSLA) {
        size_t idx = 0;
        const SLAPrint *sla_print = this->sla_print();
    std::vector<double> shift_zs(m_model->objects.size(), 0);
        double relative_correction_z = sla_print->relative_correction().z();
        if (relative_correction_z <= EPSILON)
            relative_correction_z = 1.;
    for (const SLAPrintObject *print_object : sla_print->objects()) {
            SLASupportState   &state        = sla_support_state[idx ++];
            const ModelObject *model_object = print_object->model_object();
            // Find an index of the ModelObject
            int object_idx;
            // There may be new SLA volumes added to the scene for this print_object.
            // Find the object index of this print_object in the Model::objects list.
            auto it = std::find(sla_print->model().objects.begin(), sla_print->model().objects.end(), model_object);
            assert(it != sla_print->model().objects.end());
      object_idx = it - sla_print->model().objects.begin();
      // Cache the Z offset to be applied to all volumes with this object_idx.
      shift_zs[object_idx] = print_object->get_current_elevation() / relative_correction_z;
            // Collect indices of this print_object's instances, for which the SLA support meshes are to be added to the scene.
            // pairs of <instance_idx, print_instance_idx>
      std::vector<std::pair<size_t, size_t>> instances[std::tuple_size<SLASteps>::value];
            for (size_t print_instance_idx = 0; print_instance_idx < print_object->instances().size(); ++ print_instance_idx) {
                const SLAPrintObject::Instance &instance = print_object->instances()[print_instance_idx];
                // Find index of ModelInstance corresponding to this SLAPrintObject::Instance.
        auto it = std::find_if(model_object->instances.begin(), model_object->instances.end(),
                    [&instance](const ModelInstance *mi) { return mi->id() == instance.instance_id; });
                assert(it != model_object->instances.end());
                int instance_idx = it - model_object->instances.begin();
                for (size_t istep = 0; istep < sla_steps.size(); ++ istep)
                    if (sla_steps[istep] == slaposDrillHoles) {
                      // Hollowing is a special case, where the mesh from the backend is being loaded into the 1st volume of an instance,
                      // not into its own GLVolume.
                        // There shall always be such a GLVolume allocated.
                        ModelVolumeState key(model_object->volumes.front()->id(), instance.instance_id);
                        auto it = std::lower_bound(model_volume_state.begin(), model_volume_state.end(), key, model_volume_state_lower);
                        assert(it != model_volume_state.end() && it->geometry_id == key.geometry_id);
                        assert(!it->new_geometry());
                        GLVolume &volume = *m_volumes.volumes[it->volume_idx];
                        if (! volume.offsets.empty() && state.step[istep].timestamp != volume.offsets.front()) {
                          // The backend either produced a new hollowed mesh, or it invalidated the one that the front end has seen.
                            volume.model.reset();
                            if (state.step[istep].state == PrintStateBase::DONE) {
                                TriangleMesh mesh = print_object->get_mesh(slaposDrillHoles);
                              assert(! mesh.empty());
                                mesh.transform(sla_print->sla_trafo(*m_model->objects[volume.object_idx()]).inverse());
                                volume.model.init_from(mesh);
                                volume.mesh_raycaster = std::make_unique<GUI::MeshRaycaster>(std::make_shared<TriangleMesh>(mesh));
                            }
                            else {
                            // Reload the original volume.
                                const TriangleMesh& new_mesh = m_model->objects[volume.object_idx()]->volumes[volume.volume_idx()]->mesh();
                                volume.model.init_from(new_mesh);
                                volume.mesh_raycaster = std::make_unique<GUI::MeshRaycaster>(std::make_shared<TriangleMesh>(new_mesh));
                            }
                      }
                      //FIXME it is an ugly hack to write the timestamp into the "offsets" field to not have to add another member variable
                      // to the GLVolume. We should refactor GLVolume significantly, so that the GLVolume will not contain member variables
                      // of various concenrs (model vs. 3D print path).
                      volume.offsets = { state.step[istep].timestamp };
                    }
                    else if (state.step[istep].state == PrintStateBase::DONE) {
                        // Check whether there is an existing auxiliary volume to be updated, or a new auxiliary volume to be created.
            ModelVolumeState key(state.step[istep].timestamp, instance.instance_id.id);
            auto it = std::lower_bound(aux_volume_state.begin(), aux_volume_state.end(), key, model_volume_state_lower);
            assert(it != aux_volume_state.end() && it->geometry_id == key.geometry_id);
                      if (it->new_geometry()) {
                            // This can be an SLA support structure that should not be rendered (in case someone used undo
                            // to revert to before it was generated). If that's the case, we should not generate anything.
                            if (model_object->sla_points_status != sla::PointsStatus::NoPoints)
                                instances[istep].emplace_back(std::pair<size_t, size_t>(instance_idx, print_instance_idx));
                            else
                                shift_zs[object_idx] = 0.;
                        }
                        else {
                            // Recycling an old GLVolume. Update the Object/Instance indices into the current Model.
                            m_volumes.volumes[it->volume_idx]->composite_id = GLVolume::CompositeID(object_idx, m_volumes.volumes[it->volume_idx]->volume_idx(), instance_idx);
                            m_volumes.volumes[it->volume_idx]->set_instance_transformation(model_object->instances[instance_idx]->get_transformation());
                        }
                    }
            }
 
            for (size_t istep = 0; istep < sla_steps.size(); ++istep)
                if (!instances[istep].empty())
                    m_volumes.load_object_auxiliary(print_object, object_idx, instances[istep], sla_steps[istep], state.step[istep].timestamp);
        }
 
    // Shift-up all volumes of the object so that it has the right elevation with respect to the print bed
    for (GLVolume* volume : m_volumes.volumes)
      if (volume->object_idx() < (int)m_model->objects.size() && m_model->objects[volume->object_idx()]->instances[volume->instance_idx()]->is_printable())
        volume->set_sla_shift_z(shift_zs[volume->object_idx()]);
    }
 
    // BBS
    if (printer_technology == ptFFF && m_config->has("filament_colour") && (m_canvas_type != ECanvasType::CanvasAssembleView)) {
        // Should the wipe tower be visualized ?
        unsigned int filaments_count = (unsigned int)dynamic_cast<const ConfigOptionStrings*>(m_config->option("filament_colour"))->values.size();
 
        bool wt = dynamic_cast<const ConfigOptionBool*>(m_config->option("enable_prime_tower"))->value;
        auto co = dynamic_cast<const ConfigOptionEnum<PrintSequence>*>(m_config->option<ConfigOptionEnum<PrintSequence>>("print_sequence"));
 
        const DynamicPrintConfig &dconfig           = wxGetApp().preset_bundle->prints.get_edited_preset().config;
        auto timelapse_type = dconfig.option<ConfigOptionEnum<TimelapseType>>("timelapse_type");
        bool need_wipe_tower = timelapse_type ? (timelapse_type->value == TimelapseType::tlSmooth) : false;
 
        if (dconfig.has("enable_wrapping_detection")) {
            need_wipe_tower |= dynamic_cast<const ConfigOptionBool*>(dconfig.option("enable_wrapping_detection"))->value;
        }
 
        // Belt printers replace the classic wipe tower with the auto-generated
        // belt purge prism (a real model object), so never draw the tower widget.
        bool is_belt_printer = false;
        if (const auto *belt_opt = wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionBool>("belt_printer"))
            is_belt_printer = belt_opt->value;
 
        if (wt && !is_belt_printer && (need_wipe_tower || filaments_count > 1) && !wxGetApp().plater()->only_gcode_mode() && !wxGetApp().plater()->is_gcode_3mf()) {
            // The tower size estimate reads printer- and filament-scope keys, which the print preset
            // does not carry; built once here rather than per plate.
            const DynamicPrintConfig full_config = wxGetApp().preset_bundle->full_config();
            for (int plate_id = 0; plate_id < n_plates; plate_id++) {
                // If print ByObject and there is only one object in the plate, the wipe tower is allowed to be generated.
                PartPlate* part_plate = ppl.get_plate(plate_id);
                if (part_plate->get_print_seq() == PrintSequence::ByObject ||
                    (part_plate->get_print_seq() == PrintSequence::ByDefault && co != nullptr && co->value == PrintSequence::ByObject)) {
                    if (ppl.get_plate(plate_id)->printable_instance_size() != 1)
                        continue;
                }
 
                DynamicPrintConfig& proj_cfg = wxGetApp().preset_bundle->project_config;
                float x = dynamic_cast<const ConfigOptionFloats*>(proj_cfg.option("wipe_tower_x"))->get_at(plate_id);
                float y = dynamic_cast<const ConfigOptionFloats*>(proj_cfg.option("wipe_tower_y"))->get_at(plate_id);
                float a = dynamic_cast<const ConfigOptionFloat*>(m_config->option("wipe_tower_rotation_angle"))->value;
                Vec3d plate_origin = ppl.get_plate(plate_id)->get_origin();
 
                const Print* current_print = part_plate->fff_print();
                if (part_plate->get_objects_on_this_plate().empty()) continue;
 
                // Body and brim from this plate's own estimate: m_process->fff_print() is the
                // selected plate's, so an auto brim drew every tower with that plate's brim.
                const WipeTowerFootprint footprint = part_plate->estimate_wipe_tower_footprint(full_config);
                // The estimate is also the answer to whether this plate prints a tower;
                // deciding it here as well only gave the two room to drift.
                if (footprint.depth <= 0.) continue;
                float brim_width = float(footprint.brim_width);
                Vec3d wipe_tower_size(footprint.width, footprint.depth, footprint.height);
 
                // set_default_wipe_tower_pos_for_plate doesn't rerun when painting changes the
                // filament count, so redo its clamp here on every reload — unconditionally: a
                // paint-triggered reload can arrive before the background process invalidates
                // psWipeTower, so gating on it would skip the clamp exactly when it is needed.
                {
                    Vec3d clamped_pos, clamped_size;
                    WipeTowerRelocation relocation;
                    part_plate->estimate_wipe_tower_polygon(full_config, plate_id, clamped_pos, clamped_size, 0, false, &relocation);
                    if (std::abs(x - (float) clamped_pos(0)) > EPSILON || std::abs(y - (float) clamped_pos(1)) > EPSILON) {
                        x = (float) clamped_pos(0);
                        y = (float) clamped_pos(1);
                        ConfigOptionFloat wt_x_opt(x), wt_y_opt(y);
                        dynamic_cast<ConfigOptionFloats*>(proj_cfg.option("wipe_tower_x"))->set_at(&wt_x_opt, plate_id, 0);
                        dynamic_cast<ConfigOptionFloats*>(proj_cfg.option("wipe_tower_y"))->set_at(&wt_y_opt, plate_id, 0);
                        // The stored position changes once, so this is shown once per move.
                        if (NotificationManager *notifications = wxGetApp().notification_manager(); notifications != nullptr && relocation.moved) {
                            if (relocation.overlaps_objects)
                                notifications->push_notification(NotificationType::CustomNotification, NotificationManager::NotificationLevel::WarningNotificationLevel,
                                    // TRN %1% is the plate number.
                                    format(_u8L("The prime tower on plate %1% no longer fits where it was placed. There is no free space left on the plate for it, so it was moved onto an object."), plate_id + 1));
                            else
                                notifications->push_notification(NotificationType::CustomNotification, NotificationManager::NotificationLevel::RegularNotificationLevel,
                                    // TRN %1% is the plate number.
                                    format(_u8L("The prime tower on plate %1% no longer fits where it was placed, so it was moved to free space on the plate."), plate_id + 1));
                        }
                    }
                }
 
                if (!current_print->is_step_done(psWipeTower) || !current_print->wipe_tower_data().wipe_tower_mesh_data) {
                    // update for wipe tower position
                    int volume_idx_wipe_tower_new = m_volumes.load_wipe_tower_preview(1000 + plate_id, x + plate_origin(0), y + plate_origin(1),
                                                                                      (float) wipe_tower_size(0), (float) wipe_tower_size(1), (float) wipe_tower_size(2),
                                                                                      a, true, brim_width);
                    int volume_idx_wipe_tower_old = volume_idxs_wipe_tower_old[plate_id];
                    if (volume_idx_wipe_tower_old != -1) map_glvolume_old_to_new[volume_idx_wipe_tower_old] = volume_idx_wipe_tower_new;
                } else {
                    int volume_idx_wipe_tower_new = m_volumes.load_real_wipe_tower_preview(1000 + plate_id, x + plate_origin(0), y + plate_origin(1),
                                                                                           current_print->wipe_tower_data().wipe_tower_mesh_data->real_wipe_tower_mesh,
                                                                                           current_print->wipe_tower_data().wipe_tower_mesh_data->real_brim_mesh,
                                                                                        true,a, true, m_initialized);
                    int volume_idx_wipe_tower_old = volume_idxs_wipe_tower_old[plate_id];
                    if (volume_idx_wipe_tower_old != -1) map_glvolume_old_to_new[volume_idx_wipe_tower_old] = volume_idx_wipe_tower_new;
                }
            }
        }
    }
 
    update_volumes_colors_by_extruder();
 
    // ORCA-Belt: render the auto-generated belt purge prism like a wipe tower —
    // semi-transparent, in its (filament) color. It is a real sliced object, so
    // the G-code preview already shows the actual per-layer purge colors; here in
    // the editor we just make the block translucent so it reads as a purge tower
    // rather than a solid part. update_colors_by_extruder() preserves alpha when
    // not updating alpha, so lowering it once sticks across recolors.
    if (m_model != nullptr) {
        for (GLVolume *volume : m_volumes.volumes) {
            if (volume == nullptr || volume->volume_idx() < 0)
                continue;
            const int obj_idx = volume->object_idx();
            if (obj_idx < 0 || obj_idx >= (int) m_model->objects.size())
                continue;
            const ConfigOption *opt = m_model->objects[obj_idx]->config.option("belt_purge_tower_object");
            if (opt != nullptr && opt->getBool()) {
                volume->color.a(0.66f);
                volume->force_transparent = true;
            }
        }
    }
 
  // Update selection indices based on the old/new GLVolumeCollection.
    if (m_selection.get_mode() == Selection::Instance)
        m_selection.instances_changed(instance_ids_selected);
    else
        m_selection.volumes_changed(map_glvolume_old_to_new);
 
    // @Enrico suggest this solution to preven accessing pointer on caster without data
    m_scene_raycaster.remove_raycasters(SceneRaycaster::EType::Bed);
    m_scene_raycaster.remove_raycasters(SceneRaycaster::EType::Volume);
    m_gizmos.update_data();
    m_gizmos.refresh_on_off_state();
 
    // Update the toolbar
    //BBS: notify the PartPlateList to reload all objects
    if (update_object_list)
        post_event(SimpleEvent(EVT_GLCANVAS_OBJECT_SELECT));
 
    //BBS:exclude the assmble view
    if (m_canvas_type != ECanvasType::CanvasAssembleView) {
        _update_slice_error_status();
        // checks for geometry outside the print volume to render it accordingly
        if (!m_volumes.empty()) {
            ModelInstanceEPrintVolumeState state;
            ObjectFilamentResults object_results;
            const bool contained_min_one = m_volumes.check_outside_state(m_bed.build_volume(), &state, &object_results);
            const bool partlyOut = (state == ModelInstanceEPrintVolumeState::ModelInstancePVS_Partly_Outside);
            const bool fullyOut = (state == ModelInstanceEPrintVolumeState::ModelInstancePVS_Fully_Outside);
           // const bool objectLimited = (state == ModelInstanceEPrintVolumeState::ModelInstancePVS_Limited);
 
            PartPlate *cur_plate  = wxGetApp().plater()->get_partplate_list().get_curr_plate();
            bool show_read_wipe_tower = cur_plate->fff_print()->is_step_done(psWipeTower);
            bool       wipe_tower_outside   = m_volumes.check_wipe_tower_outside_state(m_bed.build_volume(), wxGetApp().plater()->get_partplate_list().get_curr_plate_index());
            bool show_wipe_tower_outside_error = show_read_wipe_tower ? !wipe_tower_outside : false;
            _set_warning_notification(EWarning::PrimeTowerOutside, show_wipe_tower_outside_error);
 
            auto clash_flag = construct_error_string(object_results, get_object_clashed_text());
            auto unprintable_flag= construct_extruder_unprintable_error(object_results, get_left_extruder_unprintable_text(), get_right_extruder_unprintable_text());
 
            bool is_flushing_volume_valid = is_flushing_matrix_error();
            _set_warning_notification(EWarning::FlushingVolumeZero, is_flushing_volume_valid);
            _set_warning_notification(EWarning::ObjectClashed, clash_flag);
            _set_warning_notification(EWarning::LeftExtruderPrintableError, unprintable_flag.first);
            _set_warning_notification(EWarning::RightExtruderPrintableError, unprintable_flag.second);
            //_set_warning_notification(EWarning::ObjectLimited, objectLimited);
            //BBS: turn off the warning when fully outside
            //_set_warning_notification(EWarning::ObjectOutside, fullyOut);
            //if (printer_technology != ptSLA || !contained_min_one)
            //    _set_warning_notification(EWarning::SlaSupportsOutside, false);
 
            auto full_config_temp = wxGetApp().preset_bundle->full_config();
            bool tpu_valid = cur_plate->check_tpu_printable_status(full_config_temp, wxGetApp().preset_bundle->get_used_tpu_filaments(cur_plate->get_extruders(true)));
            _set_warning_notification(EWarning::TPUPrintableError, !tpu_valid);
 
            bool filament_printable = cur_plate->check_filament_printable(full_config_temp, filament_printable_error_msg);
            _set_warning_notification(EWarning::FilamentPrintableError, !filament_printable);
 
            bool mix_pla_and_petg = cur_plate->check_mixture_of_pla_and_petg(full_config_temp);
            _set_warning_notification(EWarning::MixUsePLAAndPETG, !mix_pla_and_petg);
 
            bool single_extruder_mixed_risk = cur_plate->check_single_extruder_mixed_filament_risk(full_config_temp, get_single_extruder_mixed_filament_warning_text());
            _set_warning_notification(EWarning::SingleExtruderMixedFilament, single_extruder_mixed_risk);
 
            bool filament_nozzle_compatible = cur_plate->check_compatible_of_nozzle_and_filament(full_config_temp, wxGetApp().preset_bundle->filament_presets, get_nozzle_filament_incompatible_text());
            _set_warning_notification(EWarning::NozzleFilamentIncompatible, !filament_nozzle_compatible);
 
            bool filament_mixture_compatible = cur_plate->check_mixture_filament_compatible(full_config_temp, get_filament_mixture_warning_text());
            _set_warning_notification(EWarning::MixtureFilamentIncompatible, !filament_mixture_compatible);
 
            bool model_fits = contained_min_one && !m_model->objects.empty() && !partlyOut && object_results.filaments.empty() && tpu_valid && filament_printable;
            // Honor the missing-plugin block so this geometry-only path does not re-enable slicing
            // that Plater::validate_current_plate disabled (otherwise moving an object would briefly
            // re-enable the Slice button while required plugins are still missing).
            if (wxGetApp().plater() && wxGetApp().plater()->plugins_block_slicing())
                model_fits = false;
            post_event(Event<bool>(EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, model_fits));
            ppl.get_curr_plate()->update_slice_ready_status(model_fits);
        }
        else {
            _set_warning_notification(EWarning::ObjectOutside, false);
            _set_warning_notification(EWarning::FlushingVolumeZero, false);
            _set_warning_notification(EWarning::ObjectClashed, false);
            _set_warning_notification(EWarning::LeftExtruderPrintableError, false);
            _set_warning_notification(EWarning::RightExtruderPrintableError, false);
            //_set_warning_notification(EWarning::ObjectLimited, false);
            //_set_warning_notification(EWarning::SlaSupportsOutside, false);
           _set_warning_notification(EWarning::TPUPrintableError, false);
           _set_warning_notification(EWarning::FilamentPrintableError, false);
           _set_warning_notification(EWarning::MixUsePLAAndPETG, false);
           _set_warning_notification(EWarning::SingleExtruderMixedFilament, false);
           _set_warning_notification(EWarning::PrimeTowerOutside, false);
           _set_warning_notification(EWarning::MultiExtruderPrintableError,false);
           _set_warning_notification(EWarning::MultiExtruderHeightOutside,false);
           _set_warning_notification(EWarning::NozzleFilamentIncompatible,false);
           _set_warning_notification(EWarning::MixtureFilamentIncompatible,false);
 
           post_event(Event<bool>(EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, false));
        }
    }
 
    refresh_camera_scene_box();
 
    if (m_selection.is_empty()) {
        // If no object is selected, deactivate the active gizmo, if any
        // Otherwise it may be shown after cleaning the scene (if it was active while the objects were deleted)
        m_gizmos.reset_all_states();
        // BBS
#if 0
        // If no object is selected, reset the objects manipulator on the sidebar
        // to force a reset of its cache
        auto manip = wxGetApp().obj_manipul();
        if (manip != nullptr)
            manip->set_dirty();
#endif
    }
 
    // refresh bed raycasters for picking
    if (m_canvas_type == ECanvasType::CanvasView3D) {
        wxGetApp().plater()->get_partplate_list().register_raycasters_for_picking(*this);
    }
 
    // refresh volume raycasters for picking
    for (size_t i = 0; i < m_volumes.volumes.size(); ++i) {
        const GLVolume* v = m_volumes.volumes[i];
        assert(v->mesh_raycaster != nullptr);
        std::shared_ptr<SceneRaycasterItem> raycaster = add_raycaster_for_picking(SceneRaycaster::EType::Volume, i, *v->mesh_raycaster, v->world_matrix());
        raycaster->set_active(v->is_active);
    }
 
    // refresh gizmo elements raycasters for picking
    GLGizmoBase* curr_gizmo = m_gizmos.get_current();
    if (curr_gizmo != nullptr)
        curr_gizmo->unregister_raycasters_for_picking();
    m_scene_raycaster.remove_raycasters(SceneRaycaster::EType::Gizmo);
    m_scene_raycaster.remove_raycasters(SceneRaycaster::EType::FallbackGizmo);
    if (curr_gizmo != nullptr && !m_selection.is_empty())
        curr_gizmo->register_raycasters_for_picking();
 
    // and force this canvas to be redrawn.
    m_dirty = true;
}

Referenced by _render_frame(), anonymous_namespace{EmbossJob.cpp}::CreateObjectJob::finalize(), Slic3r::GUI::ObjectList::list_manipulation(), and Slic3r::GUI::ObjectList::OnEditingStarted().

Here is the caller graph for this function:

◆ remove_curr_plate_all()

void Slic3r::GUI::GLCanvas3D::remove_curr_plate_all ( )

{
    m_selection.remove_curr_plate();
    m_dirty = true;
}

References m_dirty, and m_selection.

◆ remove_raycasters_for_picking() [1/2]

void Slic3r::GUI::GLCanvas3D::remove_raycasters_for_picking ( SceneRaycaster::EType type )

inline

                                                                 {
        m_scene_raycaster.remove_raycasters(type);
    }

References m_scene_raycaster.

◆ remove_raycasters_for_picking() [2/2]

void Slic3r::GUI::GLCanvas3D::remove_raycasters_for_picking	(	SceneRaycaster::EType	type,
		int	id )

inline

                                                                         {
        m_scene_raycaster.remove_raycasters(type, id);
    }

References m_scene_raycaster.

Referenced by Slic3r::GUI::PartPlate::register_raycasters_for_picking().

Here is the caller graph for this function:

◆ render()

void Slic3r::GUI::GLCanvas3D::render ( bool only_init = false )

{
    m_presented_signature.reset();
    _render_frame(true, only_init);
}

References _render_frame(), and m_presented_signature.

Referenced by bind_event_handlers(), Slic3r::GUI::GLToolbar::do_action(), on_char(), on_key(), on_mouse(), on_mouse_wheel(), and on_paint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_thumbnail() [1/3]

void Slic3r::GUI::GLCanvas3D::render_thumbnail	(	ThumbnailData &	thumbnail_data,
		std::vector< ColorRGBA > &	extruder_colors,
		unsigned int	w,
		unsigned int	h,
		const ThumbnailsParams &	thumbnail_params,
		ModelObjectPtrs &	model_objects,
		const GLVolumeCollection &	volumes,
		Camera::EType	camera_type,
		Camera::ViewAngleType	camera_view_angle_type = Camera::ViewAngleType::Iso,
		bool	for_picking = false,
		bool	ban_light = false )

{
    if (!_set_shown_canvas_current())
        return;
 
    GLShaderProgram *shader = wxGetApp().get_shader("thumbnail");
    switch (OpenGLManager::get_framebuffers_type()) {
        case OpenGLManager::EFramebufferType::Arb: {
            render_thumbnail_framebuffer(thumbnail_data, w, h, thumbnail_params, wxGetApp().plater()->get_partplate_list(), model_objects, volumes, extruder_colors, shader,
                                         camera_type, camera_view_angle_type, for_picking, ban_light);
            break;
        }
        case OpenGLManager::EFramebufferType::Ext: {
            render_thumbnail_framebuffer_ext(thumbnail_data, w, h, thumbnail_params, wxGetApp().plater()->get_partplate_list(), model_objects, volumes, extruder_colors, shader,
                                             camera_type, camera_view_angle_type, for_picking, ban_light);
            break;
        }
        default: {
            render_thumbnail_legacy(thumbnail_data, w, h, thumbnail_params, wxGetApp().plater()->get_partplate_list(), model_objects, volumes, extruder_colors, shader, camera_type, camera_view_angle_type, for_picking, ban_light);
            break;
        }
    }
}

References _set_shown_canvas_current(), Slic3r::GUI::OpenGLManager::Arb, Slic3r::GUI::OpenGLManager::Ext, Slic3r::GUI::OpenGLManager::get_framebuffers_type(), Slic3r::GUI::plater(), render_thumbnail_framebuffer(), render_thumbnail_framebuffer_ext(), and render_thumbnail_legacy().

Here is the call graph for this function:

◆ render_thumbnail() [2/3]

void Slic3r::GUI::GLCanvas3D::render_thumbnail	(	ThumbnailData &	thumbnail_data,
		unsigned int	w,
		unsigned int	h,
		const ThumbnailsParams &	thumbnail_params,
		Camera::EType	camera_type,
		Camera::ViewAngleType	camera_view_angle_type = Camera::ViewAngleType::Iso,
		bool	for_picking = false,
		bool	ban_light = false )

{
    ModelObjectPtrs &model_objects = GUI::wxGetApp().model().objects;
    render_thumbnail(thumbnail_data, w, h, thumbnail_params, model_objects, m_volumes, camera_type, camera_view_angle_type, for_picking, ban_light);
}

References m_volumes, and render_thumbnail().

Referenced by render_thumbnail(), Slic3r::GUI::Plater::update_obj_preview_thumbnail(), and Slic3r::GUI::Plater::update_plate_thumbnails().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_thumbnail() [3/3]

void Slic3r::GUI::GLCanvas3D::render_thumbnail	(	ThumbnailData &	thumbnail_data,
		unsigned int	w,
		unsigned int	h,
		const ThumbnailsParams &	thumbnail_params,
		ModelObjectPtrs &	model_objects,
		const GLVolumeCollection &	volumes,
		Camera::EType	camera_type,
		Camera::ViewAngleType	camera_view_angle_type = Camera::ViewAngleType::Iso,
		bool	for_picking = false,
		bool	ban_light = false )

{
    if (!_set_shown_canvas_current())
        return;
 
    GLShaderProgram* shader = nullptr;
    if (for_picking)
        shader = wxGetApp().get_shader("flat");
    else
        shader = wxGetApp().get_shader("thumbnail");
    std::vector<ColorRGBA> colors = wxGetApp().plater()->get_extruders_colors();
    switch (OpenGLManager::get_framebuffers_type())
    {
    case OpenGLManager::EFramebufferType::Arb:
        { render_thumbnail_framebuffer(thumbnail_data, w, h, thumbnail_params, wxGetApp().plater()->get_partplate_list(), model_objects, volumes, colors, shader, camera_type,
                                     camera_view_angle_type, for_picking, ban_light);
        break;
    }
    case OpenGLManager::EFramebufferType::Ext:
        { render_thumbnail_framebuffer_ext(thumbnail_data, w, h, thumbnail_params, wxGetApp().plater()->get_partplate_list(), model_objects, volumes, colors, shader, camera_type,
                                         camera_view_angle_type, for_picking, ban_light);
        break;
    }
    default:{
        render_thumbnail_legacy(thumbnail_data, w, h, thumbnail_params, wxGetApp().plater()->get_partplate_list(), model_objects, volumes, colors, shader, camera_type,
                                camera_view_angle_type, for_picking, ban_light);
        break;
    }
    }
}

References _set_shown_canvas_current(), Slic3r::GUI::OpenGLManager::Arb, Slic3r::GUI::OpenGLManager::Ext, Slic3r::GUI::OpenGLManager::get_framebuffers_type(), Slic3r::GUI::plater(), render_thumbnail_framebuffer(), render_thumbnail_framebuffer_ext(), and render_thumbnail_legacy().

Here is the call graph for this function:

◆ render_thumbnail_framebuffer()

void Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer	(	ThumbnailData &	thumbnail_data,
		unsigned int	w,
		unsigned int	h,
		const ThumbnailsParams &	thumbnail_params,
		PartPlateList &	partplate_list,
		ModelObjectPtrs &	model_objects,
		const GLVolumeCollection &	volumes,
		std::vector< ColorRGBA > &	extruder_colors,
		GLShaderProgram *	shader,
		Camera::EType	camera_type,
		Camera::ViewAngleType	camera_view_angle_type = Camera::ViewAngleType::Iso,
		bool	for_picking = false,
		bool	ban_light = false )

static

{
    thumbnail_data.set(w, h);
    if (!thumbnail_data.is_valid())
        return;
 
    bool multisample = OpenGLManager::can_multisample();
    if (for_picking)
        multisample = false;
    //if (!multisample)
    //    glsafe(::glEnable(GL_MULTISAMPLE));
 
    GLint max_samples;
    glsafe(::glGetIntegerv(GL_MAX_SAMPLES, &max_samples));
    GLsizei num_samples = max_samples / 2;
 
    GLuint render_fbo;
    glsafe(::glGenFramebuffers(1, &render_fbo));
    glsafe(::glBindFramebuffer(GL_FRAMEBUFFER, render_fbo));
 
    BOOST_LOG_TRIVIAL(info) << boost::format("render_thumbnail prepare: w %1%, h %2%, max_samples  %3%, render_fbo %4%") %w %h %max_samples % render_fbo;
    GLuint render_tex = 0;
    GLuint render_tex_buffer = 0;
    if (multisample) {
        // use renderbuffer instead of texture to avoid the need to use glTexImage2DMultisample which is available only since OpenGL 3.2
        glsafe(::glGenRenderbuffers(1, &render_tex_buffer));
        glsafe(::glBindRenderbuffer(GL_RENDERBUFFER, render_tex_buffer));
        glsafe(::glRenderbufferStorageMultisample(GL_RENDERBUFFER, num_samples, GL_RGBA8, w, h));
        glsafe(::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, render_tex_buffer));
    }
    else {
        glsafe(::glGenTextures(1, &render_tex));
        glsafe(::glBindTexture(GL_TEXTURE_2D, render_tex));
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr));
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
        glsafe(::glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, render_tex, 0));
    }
 
    GLuint render_depth;
    glsafe(::glGenRenderbuffers(1, &render_depth));
    glsafe(::glBindRenderbuffer(GL_RENDERBUFFER, render_depth));
    if (multisample)
        glsafe(::glRenderbufferStorageMultisample(GL_RENDERBUFFER, num_samples, GL_DEPTH_COMPONENT24, w, h));
    else
        glsafe(::glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, w, h));
 
    glsafe(::glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, render_depth));
 
    GLenum drawBufs[] = { GL_COLOR_ATTACHMENT0 };
    glsafe(::glDrawBuffers(1, drawBufs));
 
    if (::glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) {
        render_thumbnail_internal(thumbnail_data, thumbnail_params, partplate_list, model_objects, volumes, extruder_colors, shader, camera_type, camera_view_angle_type,
                                  for_picking, ban_light);
 
        if (multisample) {
            GLuint resolve_fbo;
            glsafe(::glGenFramebuffers(1, &resolve_fbo));
            glsafe(::glBindFramebuffer(GL_FRAMEBUFFER, resolve_fbo));
 
            GLuint resolve_tex;
            glsafe(::glGenTextures(1, &resolve_tex));
            glsafe(::glBindTexture(GL_TEXTURE_2D, resolve_tex));
            glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr));
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
            glsafe(::glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, resolve_tex, 0));
 
            glsafe(::glDrawBuffers(1, drawBufs));
 
            if (::glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) {
                glsafe(::glBindFramebuffer(GL_READ_FRAMEBUFFER, render_fbo));
                glsafe(::glBindFramebuffer(GL_DRAW_FRAMEBUFFER, resolve_fbo));
                glsafe(::glBlitFramebuffer(0, 0, w, h, 0, 0, w, h, GL_COLOR_BUFFER_BIT, GL_LINEAR));
 
                glsafe(::glBindFramebuffer(GL_READ_FRAMEBUFFER, resolve_fbo));
                glsafe(::glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, (void*)thumbnail_data.pixels.data()));
            }
 
            glsafe(::glDeleteTextures(1, &resolve_tex));
            glsafe(::glDeleteFramebuffers(1, &resolve_fbo));
        }
        else
            glsafe(::glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, (void*)thumbnail_data.pixels.data()));
 
#if ENABLE_THUMBNAIL_GENERATOR_DEBUG_OUTPUT
        debug_output_thumbnail(thumbnail_data);
#endif // ENABLE_THUMBNAIL_GENERATOR_DEBUG_OUTPUT
    }
    else {
        BOOST_LOG_TRIVIAL(info) << boost::format("render_thumbnail prepare: GL_FRAMEBUFFER not complete");
    }
 
    glsafe(::glBindFramebuffer(GL_FRAMEBUFFER, 0));
    glsafe(::glDeleteRenderbuffers(1, &render_depth));
    if (render_tex_buffer != 0)
        glsafe(::glDeleteRenderbuffers(1, &render_tex_buffer));
    if (render_tex != 0)
        glsafe(::glDeleteTextures(1, &render_tex));
    glsafe(::glDeleteFramebuffers(1, &render_fbo));
 
    //if (!multisample)
    //    glsafe(::glDisable(GL_MULTISAMPLE));
    BOOST_LOG_TRIVIAL(info) << boost::format("render_thumbnail prepare: finished");
}

References Slic3r::GUI::OpenGLManager::can_multisample(), GL_COLOR_ATTACHMENT0, GL_COLOR_BUFFER_BIT, GL_DEPTH_ATTACHMENT, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT24, GL_DRAW_FRAMEBUFFER, GL_FRAMEBUFFER, GL_FRAMEBUFFER_COMPLETE, GL_LINEAR, GL_MAX_SAMPLES, GL_READ_FRAMEBUFFER, GL_RENDERBUFFER, GL_RGBA, GL_RGBA8, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_UNSIGNED_BYTE, glBindFramebuffer, glBindRenderbuffer, glBindTexture, glBlitFramebuffer, glCheckFramebufferStatus, glDeleteFramebuffers, glDeleteRenderbuffers, glDeleteTextures, glDrawBuffers, glFramebufferRenderbuffer, glFramebufferTexture2D, glGenFramebuffers, glGenRenderbuffers, glGenTextures, glGetIntegerv, glReadPixels, glRenderbufferStorage, glRenderbufferStorageMultisample, glsafe, glTexImage2D, glTexParameteri, Slic3r::ThumbnailData::is_valid(), Slic3r::ThumbnailData::pixels, render_thumbnail_internal(), and Slic3r::ThumbnailData::set().

Referenced by Slic3r::GUI::CalibUtils::process_and_store_3mf(), render_thumbnail(), render_thumbnail(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_thumbnail_framebuffer_ext()

void Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer_ext	(	ThumbnailData &	thumbnail_data,
		unsigned int	w,
		unsigned int	h,
		const ThumbnailsParams &	thumbnail_params,
		PartPlateList &	partplate_list,
		ModelObjectPtrs &	model_objects,
		const GLVolumeCollection &	volumes,
		std::vector< ColorRGBA > &	extruder_colors,
		GLShaderProgram *	shader,
		Camera::EType	camera_type,
		Camera::ViewAngleType	camera_view_angle_type = Camera::ViewAngleType::Iso,
		bool	for_picking = false,
		bool	ban_light = false )

static

{
    thumbnail_data.set(w, h);
    if (!thumbnail_data.is_valid())
        return;
 
    bool multisample = OpenGLManager::can_multisample();
    if (for_picking)
        multisample = false;
    //if (!multisample)
    //    glsafe(::glEnable(GL_MULTISAMPLE));
 
    GLint max_samples;
    glsafe(::glGetIntegerv(GL_MAX_SAMPLES_EXT, &max_samples));
    GLsizei num_samples = max_samples / 2;
 
    GLuint render_fbo;
    glsafe(::glGenFramebuffersEXT(1, &render_fbo));
    glsafe(::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, render_fbo));
 
    GLuint render_tex = 0;
    GLuint render_tex_buffer = 0;
    if (multisample) {
        // use renderbuffer instead of texture to avoid the need to use glTexImage2DMultisample which is available only since OpenGL 3.2
        glsafe(::glGenRenderbuffersEXT(1, &render_tex_buffer));
        glsafe(::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, render_tex_buffer));
        glsafe(::glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, num_samples, GL_RGBA8, w, h));
        glsafe(::glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, render_tex_buffer));
    }
    else {
        glsafe(::glGenTextures(1, &render_tex));
        glsafe(::glBindTexture(GL_TEXTURE_2D, render_tex));
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr));
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
        glsafe(::glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, render_tex, 0));
    }
 
    GLuint render_depth;
    glsafe(::glGenRenderbuffersEXT(1, &render_depth));
    glsafe(::glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, render_depth));
    if (multisample)
        glsafe(::glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, num_samples, GL_DEPTH_COMPONENT24, w, h));
    else
        glsafe(::glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, w, h));
 
    glsafe(::glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, render_depth));
 
    GLenum drawBufs[] = { GL_COLOR_ATTACHMENT0_EXT };
    glsafe(::glDrawBuffers(1, drawBufs));
 
    if (::glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT) {
        render_thumbnail_internal(thumbnail_data, thumbnail_params, partplate_list, model_objects, volumes, extruder_colors, shader, camera_type, camera_view_angle_type,
                                  for_picking,
                                  ban_light);
 
        if (multisample) {
            GLuint resolve_fbo;
            glsafe(::glGenFramebuffersEXT(1, &resolve_fbo));
            glsafe(::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, resolve_fbo));
 
            GLuint resolve_tex;
            glsafe(::glGenTextures(1, &resolve_tex));
            glsafe(::glBindTexture(GL_TEXTURE_2D, resolve_tex));
            glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr));
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
            glsafe(::glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, resolve_tex, 0));
 
            glsafe(::glDrawBuffers(1, drawBufs));
 
            if (::glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT) {
                glsafe(::glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, render_fbo));
                glsafe(::glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, resolve_fbo));
                glsafe(::glBlitFramebufferEXT(0, 0, w, h, 0, 0, w, h, GL_COLOR_BUFFER_BIT, GL_LINEAR));
 
                glsafe(::glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, resolve_fbo));
                glsafe(::glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, (void*)thumbnail_data.pixels.data()));
            }
 
            glsafe(::glDeleteTextures(1, &resolve_tex));
            glsafe(::glDeleteFramebuffersEXT(1, &resolve_fbo));
        }
        else
            glsafe(::glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, (void*)thumbnail_data.pixels.data()));
 
#if ENABLE_THUMBNAIL_GENERATOR_DEBUG_OUTPUT
        debug_output_thumbnail(thumbnail_data);
#endif // ENABLE_THUMBNAIL_GENERATOR_DEBUG_OUTPUT
    }
 
    glsafe(::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
    glsafe(::glDeleteRenderbuffersEXT(1, &render_depth));
    if (render_tex_buffer != 0)
        glsafe(::glDeleteRenderbuffersEXT(1, &render_tex_buffer));
    if (render_tex != 0)
        glsafe(::glDeleteTextures(1, &render_tex));
    glsafe(::glDeleteFramebuffersEXT(1, &render_fbo));
 
    //if (!multisample)
    //    glsafe(::glDisable(GL_MULTISAMPLE));
}

References Slic3r::GUI::OpenGLManager::can_multisample(), GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_BUFFER_BIT, GL_DEPTH_ATTACHMENT_EXT, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT24, GL_DRAW_FRAMEBUFFER_EXT, GL_FRAMEBUFFER_COMPLETE_EXT, GL_FRAMEBUFFER_EXT, GL_LINEAR, GL_MAX_SAMPLES_EXT, GL_READ_FRAMEBUFFER_EXT, GL_RENDERBUFFER_EXT, GL_RGBA, GL_RGBA8, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_UNSIGNED_BYTE, glBindFramebufferEXT, glBindRenderbufferEXT, glBindTexture, glBlitFramebufferEXT, glCheckFramebufferStatusEXT, glDeleteFramebuffersEXT, glDeleteRenderbuffersEXT, glDeleteTextures, glDrawBuffers, glFramebufferRenderbufferEXT, glFramebufferTexture2DEXT, glGenFramebuffersEXT, glGenRenderbuffersEXT, glGenTextures, glGetIntegerv, glReadPixels, glRenderbufferStorageEXT, glRenderbufferStorageMultisampleEXT, glsafe, glTexImage2D, glTexParameteri, Slic3r::ThumbnailData::is_valid(), Slic3r::ThumbnailData::pixels, render_thumbnail_internal(), and Slic3r::ThumbnailData::set().

Referenced by Slic3r::GUI::CalibUtils::process_and_store_3mf(), render_thumbnail(), render_thumbnail(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_thumbnail_internal()

void Slic3r::GUI::GLCanvas3D::render_thumbnail_internal	(	ThumbnailData &	thumbnail_data,
		const ThumbnailsParams &	thumbnail_params,
		PartPlateList &	partplate_list,
		ModelObjectPtrs &	model_objects,
		const GLVolumeCollection &	volumes,
		std::vector< ColorRGBA > &	extruder_colors,
		GLShaderProgram *	shader,
		Camera::EType	camera_type,
		Camera::ViewAngleType	camera_view_angle_type = Camera::ViewAngleType::Iso,
		bool	for_picking = false,
		bool	ban_light = false )

static

{
    //BBS modify visible calc function
    static ColorRGBA                  curr_color;
    static const std::array<float, 4> orange = {0.923f, 0.504f, 0.264f, 1.0f};
    static const std::array<float, 4> gray   = {0.64f, 0.64f, 0.64f, 1.0f};
    GLVolumePtrs                      visible_volumes;
    BoundingBoxf3                     plate_build_volume;
    if (thumbnail_params.use_plate_box) {
        int           plate_idx          = thumbnail_params.plate_id;
        PartPlate *   plate              = partplate_list.get_plate(plate_idx);
        plate_build_volume = plate->get_build_volume();
        plate_build_volume.min(0) -= Slic3r::BuildVolume::SceneEpsilon;
        plate_build_volume.min(1) -= Slic3r::BuildVolume::SceneEpsilon;
        plate_build_volume.min(2) -= Slic3r::BuildVolume::SceneEpsilon;
        plate_build_volume.max(0) += Slic3r::BuildVolume::SceneEpsilon;
        plate_build_volume.max(1) += Slic3r::BuildVolume::SceneEpsilon;
        plate_build_volume.max(2) += Slic3r::BuildVolume::SceneEpsilon;
        /*if (m_config != nullptr) {
            double h = m_config->opt_float("printable_height");
            plate_build_volume.min(2) = std::min(plate_build_volume.min(2), -h);
            plate_build_volume.max(2) = std::max(plate_build_volume.max(2), h);
        }*/
 
        auto is_visible = [plate_idx, plate_build_volume](const GLVolume &v) {
            bool ret = v.printable;
            if (plate_idx >= 0) {
                bool          contained          = false;
                BoundingBoxf3 plate_bbox         = plate_build_volume;
                plate_bbox.min(2)                = -1e10;
                const BoundingBoxf3 &volume_bbox = v.transformed_convex_hull_bounding_box();
                if (plate_bbox.contains(volume_bbox) && (volume_bbox.max(2) > 0)) { contained = true; }
                ret &= contained;
            } else {
                ret &= (!v.shader_outside_printer_detection_enabled || !v.is_outside);
            }
            return ret;
        };
 
        for (GLVolume *vol : volumes.volumes) {
            if (!vol->is_modifier && !vol->is_wipe_tower && (!thumbnail_params.parts_only || vol->composite_id.volume_id >= 0)) {
                if (is_visible(*vol)) { visible_volumes.emplace_back(vol); }
            }
        }
        BOOST_LOG_TRIVIAL(info) << boost::format("render_thumbnail: plate_idx %1% volumes size %2%, shader %3%, use_top_view=%4%, for_picking=%5%") % plate_idx %
                                       visible_volumes.size() % shader % (int)camera_view_angle_type % for_picking;
    } else {
        visible_volumes = volumes.volumes;
    }
    //BoundingBoxf3 volumes_box = plate_build_volume;
    BoundingBoxf3 volumes_box;
    volumes_box.min.z() = 0;
    volumes_box.max.z() = 0;
    if (!visible_volumes.empty()) {
        for (const GLVolume* vol : visible_volumes) {
            volumes_box.merge(vol->transformed_bounding_box());
        }
    }
    volumes_box.min.z() = -Slic3r::BuildVolume::SceneEpsilon;
    double width = volumes_box.max.x() - volumes_box.min.x();
    double depth = volumes_box.max.y() - volumes_box.min.y();
    double height = volumes_box.max.z() - volumes_box.min.z();
    volumes_box.max.x() = volumes_box.max.x() + width * 0.01f;
    volumes_box.min.x() = volumes_box.min.x() - width * 0.01f;
    volumes_box.max.y() = volumes_box.max.y() + depth * 0.01f;
    volumes_box.min.y() = volumes_box.min.y() - depth * 0.01f;
    volumes_box.max.z() = volumes_box.max.z() + height * 0.02f;
    volumes_box.min.z() = volumes_box.min.z() - height * 0.02f;
 
    Camera camera;
    camera.set_type(camera_type);
    //BBS modify scene box to plate scene bounding box
    //plate_build_volume.min(2) = - plate_build_volume.max(2);
    if (thumbnail_params.use_plate_box) {
        camera.set_scene_box(plate_build_volume);
    }
 
    camera.set_viewport(0, 0, thumbnail_data.width, thumbnail_data.height);
    camera.apply_viewport();
 
    //BoundingBoxf3 plate_box = plate->get_bounding_box(false);
    //plate_box.min.z() = 0.0;
    //plate_box.max.z() = 0.0;
 
    if (camera_view_angle_type == Camera::ViewAngleType::Top_Plate) {
        float center_x = (plate_build_volume.max(0) + plate_build_volume.min(0))/2;
        float center_y = (plate_build_volume.max(1) + plate_build_volume.min(1))/2;
        float distance_z = plate_build_volume.max(2) - plate_build_volume.min(2);
        Vec3d center(center_x, center_y, 0.f);
        double zoom_ratio, scale_x, scale_y;
 
        scale_x = ((double)thumbnail_data.width)/(plate_build_volume.max(0) - plate_build_volume.min(0));
        scale_y = ((double)thumbnail_data.height)/(plate_build_volume.max(1) - plate_build_volume.min(1));
        zoom_ratio = (scale_x <= scale_y)?scale_x:scale_y;
        camera.look_at(center + distance_z * Vec3d::UnitZ(), center, Vec3d::UnitY());
        camera.set_zoom(zoom_ratio);
        //camera.select_view("top");
    }
    else {
        camera.select_view(camera_view_angle_type);
        camera.zoom_to_box(volumes_box);
    }
 
    const Transform3d &view_matrix = camera.get_view_matrix();
    if (thumbnail_params.use_plate_box) {
        camera.apply_projection(plate_build_volume);
    }
    else {
        camera.apply_projection(volumes_box);
    }
 
    //GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
    if (!for_picking && (shader == nullptr)) {
        BOOST_LOG_TRIVIAL(info) <<  boost::format("render_thumbnail with no picking: shader is null, return directly");
        return;
    }
 
    //if (thumbnail_params.transparent_background)
    glsafe(::glClearColor(0.f, 0.f, 0.f, 0.f));
 
 
    glsafe(::glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
    glsafe(::glEnable(GL_DEPTH_TEST));
    if (ban_light) {
        glsafe(::glDisable(GL_BLEND));
    }
    const Transform3d &projection_matrix = camera.get_projection_matrix();
 
    if (for_picking) {
        //if (OpenGLManager::can_multisample())
              // This flag is often ignored by NVIDIA drivers if rendering into a screen buffer.
        //    glsafe(::glDisable(GL_MULTISAMPLE));
        shader->start_using();
 
        glsafe(::glDisable(GL_BLEND));
 
        static const GLfloat INV_255 = 1.0f / 255.0f;
 
        // do not cull backfaces to show broken geometry, if any
        glsafe(::glDisable(GL_CULL_FACE));
 
        for (GLVolume* vol : visible_volumes) {
            // Object picking mode. Render the object with a color encoding the object index.
            // we reserve color = (0,0,0) for occluders (as the printbed)
            // so we shift volumes' id by 1 to get the proper color
            //BBS: remove the bed picking logic
            unsigned int id = vol->model_object_ID;
            //unsigned int id = 1 + volume.second.first;
            unsigned int r = (id & (0x000000FF << 0)) >> 0;
            unsigned int g = (id & (0x000000FF << 8)) >> 8;
            unsigned int b = (id & (0x000000FF << 16)) >> 16;
            unsigned int a = 0xFF;
            vol->model.set_color({(GLfloat)r * INV_255, (GLfloat)g * INV_255, (GLfloat)b * INV_255, (GLfloat)a * INV_255});
            /*curr_color[0] = (GLfloat)r * INV_255;
            curr_color[1] = (GLfloat)g * INV_255;
            curr_color[2] = (GLfloat)b * INV_255;
            curr_color[3] = (GLfloat)a * INV_255;
            shader->set_uniform("uniform_color", curr_color);*/
 
            const bool is_active = vol->is_active;
            vol->is_active = true;
            vol->picking   = true;
 
            const Transform3d model_matrix = vol->world_matrix();
            shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
            shader->set_uniform("projection_matrix", projection_matrix);
            vol->simple_render(shader, model_objects, extruder_colors);
            vol->is_active = is_active;
            vol->picking   = false;
        }
 
        //glsafe(::glDisableClientState(GL_NORMAL_ARRAY));
        //glsafe(::glDisableClientState(GL_VERTEX_ARRAY));
 
        glsafe(::glEnable(GL_CULL_FACE));
 
        //if (OpenGLManager::can_multisample())
        //    glsafe(::glEnable(GL_MULTISAMPLE));
    }
    else {
        shader->start_using();
        shader->set_uniform("emission_factor", 0.1f);
        shader->set_uniform("ban_light", ban_light);
        for (GLVolume* vol : visible_volumes) {
            //BBS set render color for thumbnails
            curr_color = vol->color;
 
            ColorRGBA new_color = adjust_color_for_rendering(curr_color);
            if (ban_light) {
                new_color[3] =(255 - (vol->extruder_id -1))/255.0f;
            }
            vol->model.set_color(new_color);
            shader->set_uniform("volume_world_matrix", vol->world_matrix());
            //BBS set all volume to orange
            //shader->set_uniform("uniform_color", orange);
            /*if (plate_idx > 0) {
                shader->set_uniform("uniform_color", orange);
            }
            else {
                shader->set_uniform("uniform_color", (vol->printable && !vol->is_outside) ? orange : gray);
            }*/
            // the volume may have been deactivated by an active gizmo
            const bool is_active = vol->is_active;
            vol->is_active = true;
            const Transform3d model_matrix = vol->world_matrix();
            shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
            shader->set_uniform("projection_matrix", projection_matrix);
            const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
            shader->set_uniform("view_normal_matrix", view_normal_matrix);
            vol->simple_render(shader,  model_objects, extruder_colors, ban_light);
            vol->is_active = is_active;
        }
        shader->stop_using();
    }
 
    glsafe(::glDisable(GL_DEPTH_TEST));
 
    //don't render plate in thumbnail
    //plate->render( false, true, true);
 
    // restore background color
    //if (thumbnail_params.transparent_background)
    //    glsafe(::glClearColor(1.0f, 1.0f, 1.0f, 1.0f));
    BOOST_LOG_TRIVIAL(info) << boost::format("render_thumbnail: finished");
 
    // Puts the canvas viewport back in place of the thumbnail one set above. The CLI renders
    // thumbnails with no application and no plater, so there is no canvas viewport to restore.
    if (wxTheApp != nullptr)
        if (Plater *plater = wxGetApp().plater(); plater != nullptr)
            plater->get_camera().apply_viewport();
}

References adjust_color_for_rendering(), camera, Slic3r::center(), Slic3r::GLVolume::composite_id, Slic3r::BoundingBox3Base< PointType >::contains(), Slic3r::GUI::PartPlate::get_build_volume(), Slic3r::GUI::PartPlateList::get_plate(), GL_BLEND, GL_COLOR_BUFFER_BIT, GL_CULL_FACE, GL_DEPTH_BUFFER_BIT, GL_DEPTH_TEST, glClear, glClearColor, glDisable, glEnable, glsafe, Slic3r::ThumbnailData::height, INV_255, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::GUI::orange, Slic3r::ThumbnailsParams::parts_only, Slic3r::ThumbnailsParams::plate_id, Slic3r::GUI::plater(), Slic3r::BuildVolume::SceneEpsilon, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), Slic3r::GUI::Camera::Top_Plate, Slic3r::ThumbnailsParams::use_plate_box, Slic3r::GLVolume::CompositeID::volume_id, Slic3r::GLVolumeCollection::volumes, and Slic3r::ThumbnailData::width.

Referenced by render_thumbnail_framebuffer(), render_thumbnail_framebuffer_ext(), and render_thumbnail_legacy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render_thumbnail_legacy()

void Slic3r::GUI::GLCanvas3D::render_thumbnail_legacy	(	ThumbnailData &	thumbnail_data,
		unsigned int	w,
		unsigned int	h,
		const ThumbnailsParams &	thumbnail_params,
		PartPlateList &	partplate_list,
		ModelObjectPtrs &	model_objects,
		const GLVolumeCollection &	volumes,
		std::vector< ColorRGBA > &	extruder_colors,
		GLShaderProgram *	shader,
		Camera::EType	camera_type,
		Camera::ViewAngleType	camera_view_angle_type = Camera::ViewAngleType::Iso,
		bool	for_picking = false,
		bool	ban_light = false )

static

{
    // check that thumbnail size does not exceed the default framebuffer size
    /*const Size& cnv_size = get_canvas_size();
    unsigned int cnv_w = (unsigned int)cnv_size.get_width();
    unsigned int cnv_h = (unsigned int)cnv_size.get_height();
    if (w > cnv_w || h > cnv_h) {
        float ratio = std::min((float)cnv_w / (float)w, (float)cnv_h / (float)h);
        w = (unsigned int)(ratio * (float)w);
        h = (unsigned int)(ratio * (float)h);
    }*/
 
    thumbnail_data.set(w, h);
    if (!thumbnail_data.is_valid())
        return;
 
    render_thumbnail_internal(thumbnail_data, thumbnail_params, partplate_list, model_objects, volumes, extruder_colors, shader, camera_type, camera_view_angle_type, for_picking,
                              ban_light);
 
    glsafe(::glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, (void*)thumbnail_data.pixels.data()));
#if ENABLE_THUMBNAIL_GENERATOR_DEBUG_OUTPUT
    debug_output_thumbnail(thumbnail_data);
#endif // ENABLE_THUMBNAIL_GENERATOR_DEBUG_OUTPUT
}

References GL_RGBA, GL_UNSIGNED_BYTE, glReadPixels, glsafe, Slic3r::ThumbnailData::is_valid(), Slic3r::ThumbnailData::pixels, render_thumbnail_internal(), and Slic3r::ThumbnailData::set().

Referenced by Slic3r::GUI::CalibUtils::process_and_store_3mf(), render_thumbnail(), and render_thumbnail().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ request_extra_frame()

void Slic3r::GUI::GLCanvas3D::request_extra_frame ( )

inline

1385{ m_extra_frame_requested = true; }

References m_extra_frame_requested.

Referenced by _on_section_view_changed(), _render_3d_navigator(), _resize(), handle_shortcut(), load_gcode_preview(), Slic3r::GUI::Plater::on_config_change(), Slic3r::GUI::GLCanvas3D::Tooltip::render(), Slic3r::GUI::Mouse3DController::render_settings_dialog(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_variable_layer_height_dialog(), and Slic3r::GUI::GizmoObjectManipulation::set_coordinates_type().

Here is the caller graph for this function:

◆ requires_check_outside_state()

void Slic3r::GUI::GLCanvas3D::requires_check_outside_state ( )

inline

990{ m_requires_check_outside_state = true; }

References m_requires_check_outside_state.

Referenced by Slic3r::GUI::Plater::changed_object(), and Slic3r::GUI::Plater::on_config_change().

Here is the caller graph for this function:

◆ reset_all_gizmos()

void Slic3r::GUI::GLCanvas3D::reset_all_gizmos ( )

inline

1325{ m_gizmos.reset_all_states(); }

References m_gizmos.

◆ reset_clipping_planes_cache()

void Slic3r::GUI::GLCanvas3D::reset_clipping_planes_cache ( )

inline

1050{ m_sla_caps[0].triangles.clear(); m_sla_caps[1].triangles.clear(); }

References m_sla_caps.

◆ reset_explosion_ratio()

void Slic3r::GUI::GLCanvas3D::reset_explosion_ratio ( )

inline

981{ m_explosion_ratio = 1.0; }

References m_explosion_ratio.

◆ reset_gcode_layers_times_cache()

void Slic3r::GUI::GLCanvas3D::reset_gcode_layers_times_cache ( )

inline

1248{ m_gcode_layers_times_cache.clear(); }

References m_gcode_layers_times_cache.

◆ reset_gcode_toolpaths()

void Slic3r::GUI::GLCanvas3D::reset_gcode_toolpaths ( )

inline

1009{ _set_shown_canvas_current(); m_gcode_viewer.reset(); }

References _set_shown_canvas_current(), and m_gcode_viewer.

Here is the call graph for this function:

◆ reset_layer_height_profile()

void Slic3r::GUI::GLCanvas3D::reset_layer_height_profile ( )

{
    wxGetApp().plater()->take_snapshot("Variable layer height - Reset");
    m_layers_editing.reset_layer_height_profile(*this);
    m_layers_editing.state = LayersEditing::Completed;
    m_dirty = true;
}

References Slic3r::GUI::GLCanvas3D::LayersEditing::Completed, m_dirty, and m_layers_editing.

◆ reset_old_size()

void Slic3r::GUI::GLCanvas3D::reset_old_size ( )

inline

1454{ m_old_size = { 0, 0 }; }

References m_old_size.

◆ reset_select_plate_toolbar_selection()

void Slic3r::GUI::GLCanvas3D::reset_select_plate_toolbar_selection ( )

                                                      {
    if (m_sel_plate_toolbar.m_all_plates_stats_item)
        m_sel_plate_toolbar.m_all_plates_stats_item->selected = false;
    if (wxGetApp().mainframe)
        wxGetApp().mainframe->update_slice_print_status(MainFrame::eEventSliceUpdate, true, true);
}

References Slic3r::GUI::MainFrame::eEventSliceUpdate, and m_sel_plate_toolbar.

◆ reset_sequential_print_clearance()

void Slic3r::GUI::GLCanvas3D::reset_sequential_print_clearance ( )

inline

                                            {
        m_sequential_print_clearance.set_visible(false);
        m_sequential_print_clearance.set_render_fill(false);
        //BBS: add the height logic
        m_sequential_print_clearance.set_polygons(Polygons(), std::vector<std::pair<Polygon, float>>());
    }

References m_sequential_print_clearance.

Referenced by do_move(), and update_compacted_wipe_tower_clearance().

Here is the caller graph for this function:

◆ reset_shells()

void Slic3r::GUI::GLCanvas3D::reset_shells ( )

inline

1261{ m_gcode_viewer.reset_shell(); }

References m_gcode_viewer.

◆ reset_volumes()

void Slic3r::GUI::GLCanvas3D::reset_volumes ( )

{
    if (!m_initialized)
        return;
 
    if (m_volumes.empty())
        return;
 
    _set_current();
 
    m_selection.clear();
    m_volumes.clear();
    m_section_view_caps.clear();
    m_dirty = true;
 
    _set_warning_notification(EWarning::ObjectOutside, false);
}

References _set_current(), _set_warning_notification(), m_dirty, m_initialized, m_section_view_caps, m_selection, m_volumes, and ObjectOutside.

Referenced by ~GLCanvas3D(), and load_sla_preview().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scene_bounding_box()

BoundingBoxf3 Slic3r::GUI::GLCanvas3D::scene_bounding_box ( ) const

{
    BoundingBoxf3 bb = volumes_bounding_box();
    bb.merge(m_bed.extended_bounding_box());
    double h = m_bed.build_volume().printable_height();
    //FIXME why -h?
    bb.min.z() = std::min(bb.min.z(), -h);
    bb.max.z() = std::max(bb.max.z(), h);
 
    //BBS merge plate scene bounding box
    if (m_canvas_type == ECanvasType::CanvasView3D) {
        PartPlateList& plate = wxGetApp().plater()->get_partplate_list();
        bb.merge(plate.get_bounding_box());
    }
 
    return bb;
}

References CanvasView3D, Slic3r::GUI::PartPlateList::get_bounding_box(), m_bed, m_canvas_type, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, and volumes_bounding_box().

Referenced by refresh_camera_scene_box().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ schedule_extra_frame()

void Slic3r::GUI::GLCanvas3D::schedule_extra_frame ( int milliseconds )

{
    // Schedule idle event right now
    if (milliseconds == 0)
    {
        // We want to wakeup idle event but most likely this is call inside render cycle so we need to wait
        if (m_in_render)
            milliseconds = 33;
        else {
            m_dirty = true;
            wxWakeUpIdle();
            return;
        }
    }
    int remaining_time = m_render_timer.GetInterval();
    // Timer is not running
    if (!m_render_timer.IsRunning()) {
        m_render_timer.StartOnce(milliseconds);
    // Timer is running - restart only if new period is shorter than remaining period
    } else {
        if (milliseconds + 20 < remaining_time) {
            m_render_timer.Stop();
            m_render_timer.StartOnce(milliseconds);
        }
    }
}

References m_dirty, m_in_render, and m_render_timer.

Referenced by on_idle(), Slic3r::GUI::NotificationManager::push_notification_data(), and Slic3r::GUI::NotificationManager::update_notifications().

Here is the caller graph for this function:

◆ select_all()

void Slic3r::GUI::GLCanvas3D::select_all ( )

{
    if (!m_gizmos.is_allow_select_all()) {
        return;
    }
    m_selection.add_all();
    m_dirty = true;
}

References m_dirty, m_gizmos, and m_selection.

◆ select_curr_plate_all()

void Slic3r::GUI::GLCanvas3D::select_curr_plate_all ( )

{
    m_selection.add_curr_plate();
    m_dirty = true;
}

References m_dirty, and m_selection.

◆ select_object_from_idx()

void Slic3r::GUI::GLCanvas3D::select_object_from_idx ( std::vector< int > & object_idxs )

                                                                   {
    m_selection.add_object_from_idx(object_idxs);
    m_dirty = true;
}

References m_dirty, and m_selection.

◆ select_plate()

void Slic3r::GUI::GLCanvas3D::select_plate ( )

{
    wxGetApp().plater()->get_partplate_list().select_plate_view();
    if (m_canvas != nullptr)
        m_canvas->Refresh();
}

References m_canvas.

◆ select_view()

void Slic3r::GUI::GLCanvas3D::select_view ( const std::string & direction )

{
    wxGetApp().plater()->get_camera().select_view(direction);
    if (m_canvas != nullptr)
        m_canvas->Refresh();
}

References m_canvas.

Referenced by _render_canvas_toolbar().

Here is the caller graph for this function:

◆ set_as_dirty()

void Slic3r::GUI::GLCanvas3D::set_as_dirty ( )

inline

984{ m_dirty = true; }

References m_dirty.

Referenced by _on_section_view_changed(), anonymous_namespace{SurfaceDrag.cpp}::dragging(), enable_layers_editing(), load_gcode_preview(), Slic3r::GUI::GLToolbar::on_mouse(), Slic3r::GUI::DesignSketchTool::on_mouse_impl(), reload_scene(), Slic3r::GUI::Mouse3DController::render_settings_dialog(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_variable_layer_height_dialog(), Slic3r::GUI::GizmoObjectManipulation::set_coordinates_type(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::set_position_by_ratio(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::set_position_to_init_layer(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::set_range_and_pos(), toggle_world_axes_visibility(), update_gizmos_on_off_state(), Slic3r::GUI::GLToolbar::update_hover_state_horizontal(), and Slic3r::GUI::GLToolbar::update_hover_state_vertical().

Here is the caller graph for this function:

◆ set_benchmarking()

void Slic3r::GUI::GLCanvas3D::set_benchmarking ( bool benchmarking )

inline

1390{ m_benchmarking = benchmarking; }

References m_benchmarking.

Referenced by Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::begin_scene().

Here is the caller graph for this function:

◆ set_clipping_plane()

void Slic3r::GUI::GLCanvas3D::set_clipping_plane	(	unsigned int	id,
		const ClippingPlane &	plane )

inline

    {
        if (id < 2)
        {
            m_clipping_planes[id] = plane;
            m_sla_caps[id].reset();
        }
    }

References m_clipping_planes, and m_sla_caps.

Referenced by Slic3r::GUI::CommonGizmosDataObjects::InstancesHider::on_update().

Here is the caller graph for this function:

◆ set_collapse_toolbar()

void Slic3r::GUI::GLCanvas3D::set_collapse_toolbar	(	GLToolbar *	toolbar,
		std::function< CollapseSide()>	side )

{
    m_collapse_toolbar = toolbar;
    m_collapse_side    = std::move(side);
}

References m_collapse_side, and m_collapse_toolbar.

◆ set_color_by()

void Slic3r::GUI::GLCanvas3D::set_color_by ( const std::string & value )

{
    m_color_by = value;
}

References m_color_by.

◆ set_color_clip_plane()

void Slic3r::GUI::GLCanvas3D::set_color_clip_plane	(	const Vec3d &	cp_normal,
		double	offset )

inline

1057{ m_volumes.set_color_clip_plane(cp_normal, offset); }

References m_volumes, and Slic3r::offset().

Here is the call graph for this function:

◆ set_color_clip_plane_colors()

void Slic3r::GUI::GLCanvas3D::set_color_clip_plane_colors ( const std::array< ColorRGBA, 2 > & colors )

inline

1058{ m_volumes.set_color_clip_plane_colors(colors); }

References m_volumes.

◆ set_config()

void Slic3r::GUI::GLCanvas3D::set_config ( const DynamicPrintConfig * config )

{
    m_config = config;
    m_layers_editing.set_config(config);
 
    // Orca: Filament shrinkage compensation
    const Print *print = fff_print();
    if (print != nullptr)
        m_layers_editing.set_shrinkage_compensation(fff_print()->shrinkage_compensation());
}

References fff_print(), m_config, and m_layers_editing.

Referenced by Slic3r::GUI::Plater::priv::schedule_background_process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_context()

void Slic3r::GUI::GLCanvas3D::set_context ( wxGLContext * context )

inline

950{ m_context = context; }

References m_context.

◆ set_cursor()

void Slic3r::GUI::GLCanvas3D::set_cursor ( ECursorType type )

{
    if ((m_canvas != nullptr) && (m_cursor_type != type))
    {
        switch (type)
        {
        case Standard: { m_canvas->SetCursor(*wxSTANDARD_CURSOR); break; }
        case Cross: { m_canvas->SetCursor(*wxCROSS_CURSOR); break; }
        }
 
        m_cursor_type = type;
    }
}

References Cross, m_canvas, m_cursor_type, and Standard.

◆ set_design_canvas()

void Slic3r::GUI::GLCanvas3D::set_design_canvas ( bool b )

inline

1111{ m_design_canvas = b; }

References m_design_canvas.

◆ set_gcode_view_type()

void Slic3r::GUI::GLCanvas3D::set_gcode_view_type ( libvgcode::EViewType type )

inline

1267{ return m_gcode_viewer.set_view_type(type); }

References m_gcode_viewer.

◆ set_imgui_scaling()

void Slic3r::GUI::GLCanvas3D::set_imgui_scaling ( )

{
    float font_size = wxGetApp().em_unit();
 
#ifdef _WIN32
    // On Windows, if manually scaled here, rendering issues can occur when the system's Display
    // scaling is greater than 300% as the font's size gets to be to large. So, use imgui font
    // scaling instead (see: ImGuiWrapper::init_font() and issue #3401)
    font_size *= (font_size > 30.0f) ? 1.0f : 1.5f;
#else
    font_size *= 1.5f;
#endif
 
#if ENABLE_RETINA_GL
    wxGetApp().imgui()->set_scaling(font_size, 1.0f, m_retina_helper->get_scale_factor());
#else
    wxGetApp().imgui()->set_scaling(font_size, m_canvas->GetContentScaleFactor(), 1.0f);
#endif
}

References m_canvas.

Referenced by _resize(), and Slic3r::GUI::MainFrame::GLResourcesPrebuild::build_step().

Here is the caller graph for this function:

◆ set_model()

void Slic3r::GUI::GLCanvas3D::set_model ( Model * model )

{
    m_model = model;
    m_selection.set_model(m_model);
}

References m_model, and m_selection.

◆ set_mouse_as_dragging()

void Slic3r::GUI::GLCanvas3D::set_mouse_as_dragging ( )

inline

1366{ m_mouse.dragging = true; }

References m_mouse.

◆ set_popup_menu_position()

void Slic3r::GUI::GLCanvas3D::set_popup_menu_position ( const Vec2d & position )

inline

1309{ m_popup_menu_positon = position; }

References m_popup_menu_positon.

Referenced by Slic3r::GUI::Plater::priv::show_right_click_menu().

Here is the caller graph for this function:

◆ set_process()

void Slic3r::GUI::GLCanvas3D::set_process ( BackgroundSlicingProcess * process )

inline

1024{ m_process = process; }

anonymous_namespace{EmbossJob.cpp}::process

bool process(std::exception_ptr &eptr)

Definition EmbossJob.cpp:1427

References m_process.

◆ set_raycaster_gizmos_on_top()

void Slic3r::GUI::GLCanvas3D::set_raycaster_gizmos_on_top ( bool value )

inline

                                                 {
        m_scene_raycaster.set_gizmos_on_top(value);
    }

References m_scene_raycaster.

◆ set_section_view_ratio()

void Slic3r::GUI::GLCanvas3D::set_section_view_ratio ( double ratio )

{
    ratio = std::clamp(ratio, 0., 1.);
    if (ratio == m_section_view->ratio)
        return;
 
    if (ratio == 0.)
        m_section_view->last_ratio = m_section_view->ratio;
    m_section_view->ratio = ratio;
    // Only the first cut faces the camera; later ones keep their angle until it is set again.
    if (m_section_view->normal.isZero())
        align_section_view_to_camera();
    else
        _on_section_view_changed();
}

References _on_section_view_changed(), align_section_view_to_camera(), and m_section_view.

Referenced by _render_canvas_toolbar(), _render_section_view_panel(), on_mouse_wheel(), and toggle_section_view().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_selected_extruder()

void Slic3r::GUI::GLCanvas3D::set_selected_extruder ( int extruder )

inline

1336{ m_selected_extruder = extruder;}

Slic3r::GUI::GLCanvas3D::m_selected_extruder

int m_selected_extruder

Definition GLCanvas3D.hpp:811

References m_selected_extruder.

◆ set_selected_visible()

void Slic3r::GUI::GLCanvas3D::set_selected_visible ( bool visible )

{
    for (unsigned int i : m_selection.get_volume_idxs()) {
        GLVolume* volume = const_cast<GLVolume*>(m_selection.get_volume(i));
        volume->visible = visible;
        volume->color.a(visible ? 1.f : GLVolume::MODEL_HIDDEN_COL.a());
        volume->render_color.a(volume->color.a());
        volume->force_native_color = !visible;
    }
}

References Slic3r::ColorRGBA::a(), Slic3r::GLVolume::color, m_selection, Slic3r::GLVolume::MODEL_HIDDEN_COL, and Slic3r::GLVolume::render_color.

Here is the call graph for this function:

◆ set_sequential_print_clearance_polygons()

void Slic3r::GUI::GLCanvas3D::set_sequential_print_clearance_polygons	(	const Polygons &	polygons,
		const std::vector< std::pair< Polygon, float > > &	height_polygons )

inline

                                                                                                                                      {
        m_sequential_print_clearance.set_polygons(polygons, height_polygons);
    }

References m_sequential_print_clearance.

Referenced by update_compacted_wipe_tower_clearance(), and update_sequential_clearance().

Here is the caller graph for this function:

◆ set_sequential_print_clearance_render_fill()

void Slic3r::GUI::GLCanvas3D::set_sequential_print_clearance_render_fill ( bool render_fill )

inline

                                                                      {
        m_sequential_print_clearance.set_render_fill(render_fill);
    }

References m_sequential_print_clearance.

Referenced by update_compacted_wipe_tower_clearance(), and update_sequential_clearance().

Here is the caller graph for this function:

◆ set_sequential_print_clearance_visible()

void Slic3r::GUI::GLCanvas3D::set_sequential_print_clearance_visible ( bool visible )

inline

                                                              {
        m_sequential_print_clearance.set_visible(visible);
    }

References m_sequential_print_clearance.

Referenced by update_compacted_wipe_tower_clearance(), and update_sequential_clearance().

Here is the caller graph for this function:

◆ set_shell_transparence()

void Slic3r::GUI::GLCanvas3D::set_shell_transparence ( float alpha = 0.2f )

                                                  {
    m_gcode_viewer.set_shell_transparency(alpha);
 
}

References m_gcode_viewer.

◆ set_shells_on_previewing()

void Slic3r::GUI::GLCanvas3D::set_shells_on_previewing ( bool is_preview )

inline

1262{ m_gcode_viewer.set_shells_on_preview(is_preview); }

References m_gcode_viewer.

◆ set_show_bed()

void Slic3r::GUI::GLCanvas3D::set_show_bed ( bool b )

inline

1112{ m_show_bed = b; }

References m_show_bed.

◆ set_slope_normal_angle()

void Slic3r::GUI::GLCanvas3D::set_slope_normal_angle ( float angle_in_deg )

inline

1410{ m_slope.set_normal_angle(angle_in_deg); }

References m_slope.

◆ set_studio_lighting()

void Slic3r::GUI::GLCanvas3D::set_studio_lighting ( bool on )

inline

952{ m_studio_lighting = on; }

References m_studio_lighting.

◆ set_tooltip()

void Slic3r::GUI::GLCanvas3D::set_tooltip ( const std::string & tooltip )

{
    if (m_canvas != nullptr)
        m_tooltip.set_text(tooltip);
}

References m_canvas, and m_tooltip.

Referenced by _render_frame().

Here is the caller graph for this function:

◆ set_type()

void Slic3r::GUI::GLCanvas3D::set_type ( ECanvasType type )

inline

951{ m_canvas_type = type; }

References m_canvas_type.

◆ set_use_clipping_planes()

void Slic3r::GUI::GLCanvas3D::set_use_clipping_planes ( bool use )

inline

1051{ m_use_clipping_planes = use; }

References m_use_clipping_planes.

Referenced by Slic3r::GUI::CommonGizmosDataObjects::InstancesHider::on_release(), and Slic3r::GUI::CommonGizmosDataObjects::InstancesHider::on_update().

Here is the caller graph for this function:

◆ set_use_color_clip_plane()

void Slic3r::GUI::GLCanvas3D::set_use_color_clip_plane ( bool use )

inline

1056{ m_volumes.set_use_color_clip_plane(use); }

References m_volumes.

◆ set_volumes_z_range()

void Slic3r::GUI::GLCanvas3D::set_volumes_z_range ( const std::array< double, 2 > & range )

inline

1249{ m_volumes.set_range(range[0] - 1e-6, range[1] + 1e-6); }

References m_volumes, and Slic3r::range().

Referenced by _render_gcode_overlay().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ share_section_view()

void Slic3r::GUI::GLCanvas3D::share_section_view ( const GLCanvas3D & owner )

inline

1066{ m_section_view = owner.m_section_view; }

References GLCanvas3D(), and m_section_view.

Here is the call graph for this function:

◆ show_labels()

void Slic3r::GUI::GLCanvas3D::show_labels ( bool show )

inline

1403{ m_labels.show(show); }

References m_labels.

◆ show_overhang()

void Slic3r::GUI::GLCanvas3D::show_overhang ( bool show )

inline

1406{ m_slope.globalUse(show); }

References m_slope.

◆ sla_print()

const SLAPrint * Slic3r::GUI::GLCanvas3D::sla_print ( ) const

{
    return (m_process == nullptr) ? nullptr : m_process->sla_print();
}

References m_process, and sla_print().

Referenced by _load_sla_shells(), _render_sla_slices(), load_sla_preview(), reload_scene(), and sla_print().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smooth_layer_height_profile()

void Slic3r::GUI::GLCanvas3D::smooth_layer_height_profile ( const HeightProfileSmoothingParams & smoothing_params )

{
    wxGetApp().plater()->take_snapshot("Variable layer height - Smooth all");
    m_layers_editing.smooth_layer_height_profile(*this, smoothing_params);
    m_layers_editing.state = LayersEditing::Completed;
    m_dirty = true;
}

References Slic3r::GUI::GLCanvas3D::LayersEditing::Completed, m_dirty, and m_layers_editing.

◆ timestamp_now()

int64_t Slic3r::GUI::GLCanvas3D::timestamp_now ( )

inlinestatic

                                   {
#ifdef _WIN32
        // Cheaper on Windows, calls GetSystemTimeAsFileTime()
        return wxGetUTCTimeMillis().GetValue();
#else
        // calls clock()
        return wxGetLocalTimeMillis().GetValue();
#endif
    }

Here is the caller graph for this function:

◆ toggle_model_objects_visibility()

void Slic3r::GUI::GLCanvas3D::toggle_model_objects_visibility	(	bool	visible,
		const ModelObject *	mo = nullptr,
		int	instance_idx = -1,
		const ModelVolume *	mv = nullptr )

{
    std::vector<std::shared_ptr<SceneRaycasterItem>>* raycasters = get_raycasters_for_picking(SceneRaycaster::EType::Volume);
    for (GLVolume* vol : m_volumes.volumes) {
        // BBS: add partplate logic
        if (vol->composite_id.object_id >= 1000 &&
            vol->composite_id.object_id < 1000 + wxGetApp().plater()->get_partplate_list().get_plate_count()) { // wipe tower
            vol->is_active = (visible && mo == nullptr);
        }
        else {
            if ((mo == nullptr || m_model->objects[vol->composite_id.object_id] == mo)
            && (instance_idx == -1 || vol->composite_id.instance_id == instance_idx)
            && (mv == nullptr || m_model->objects[vol->composite_id.object_id]->volumes[vol->composite_id.volume_id] == mv)) {
                vol->is_active = visible;
                if (!vol->is_modifier)
                    vol->color.a(1.f);
 
                if (instance_idx == -1) {
                    vol->force_native_color = false;
                    vol->force_neutral_color = false;
                } else {
                    const GLGizmosManager& gm = get_gizmos_manager();
                    auto gizmo_type = gm.get_current_type();
                    if (  (gizmo_type == GLGizmosManager::FdmSupports
                        || gizmo_type == GLGizmosManager::Seam
                        || gizmo_type == GLGizmosManager::Cut
                        || gizmo_type == GLGizmosManager::FuzzySkin)
                        && !vol->is_modifier) {
                        vol->force_neutral_color = true;
                    }
                    else if (gizmo_type == GLGizmosManager::BrimEars)
                        vol->force_neutral_color = false;
                    else if (gizmo_type == GLGizmosManager::MmSegmentation)
                        vol->is_active = false;
                    else
                        vol->force_native_color = true;
                }
            }
        }
 
        auto it = std::find_if(raycasters->begin(), raycasters->end(), [vol](std::shared_ptr<SceneRaycasterItem> item) { return item->get_raycaster() == vol->mesh_raycaster.get(); });
        if (it != raycasters->end())
            (*it)->set_active(vol->is_active);
    }
 
    if (visible && !mo)
        toggle_sla_auxiliaries_visibility(true, mo, instance_idx);
 
    if (!mo && !visible && !m_model->objects.empty() && (m_model->objects.size() > 1 || m_model->objects.front()->instances.size() > 1))
        _set_warning_notification(EWarning::SomethingNotShown, true);
 
    if (!mo && visible)
        _set_warning_notification(EWarning::SomethingNotShown, false);
}

References _set_warning_notification(), Slic3r::ColorRGBA::a(), Slic3r::GUI::GLGizmosManager::BrimEars, Slic3r::GLVolume::color, Slic3r::GLVolume::composite_id, Slic3r::GUI::GLGizmosManager::Cut, Slic3r::GUI::GLGizmosManager::FdmSupports, Slic3r::GUI::GLGizmosManager::FuzzySkin, Slic3r::GUI::GLGizmosManager::get_current_type(), get_gizmos_manager(), get_raycasters_for_picking(), Slic3r::GLVolume::CompositeID::instance_id, m_model, m_volumes, Slic3r::GUI::GLGizmosManager::MmSegmentation, Slic3r::GLVolume::CompositeID::object_id, Slic3r::GUI::plater(), Slic3r::GUI::GLGizmosManager::Seam, SomethingNotShown, toggle_sla_auxiliaries_visibility(), Slic3r::GUI::SceneRaycaster::Volume, and Slic3r::GLVolume::CompositeID::volume_id.

Referenced by Slic3r::GUI::CommonGizmosDataObjects::InstancesHider::on_release(), and Slic3r::GUI::CommonGizmosDataObjects::InstancesHider::on_update().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toggle_section_view()

void Slic3r::GUI::GLCanvas3D::toggle_section_view ( )

{
    const double last_ratio = m_section_view->last_ratio;
    set_section_view_ratio(is_section_view_active() ? 0. : last_ratio > 0. ? last_ratio : 0.5);
}

References is_section_view_active(), m_section_view, and set_section_view_ratio().

Referenced by _render_canvas_toolbar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toggle_selected_volume_visibility()

void Slic3r::GUI::GLCanvas3D::toggle_selected_volume_visibility ( bool selected_visible )

{
    m_render_sla_auxiliaries = !selected_visible;
    if (selected_visible) {
        const Selection::IndicesList &idxs = m_selection.get_volume_idxs();
        if (idxs.size() > 0) {
            for (GLVolume *vol : m_volumes.volumes) {
                if (vol->composite_id.object_id >= 1000 && vol->composite_id.object_id < 1000 + wxGetApp().plater()->get_partplate_list().get_plate_count())
                    continue; // the wipe tower
                if (vol->composite_id.volume_id >= 0) {
                    vol->is_active = false;
                }
            }
            for (unsigned int idx : idxs) {
                GLVolume *v  = const_cast<GLVolume *>(m_selection.get_volume(idx));
                v->is_active = true;
            }
        }
    } else { // show all
        for (GLVolume *vol : m_volumes.volumes) {
            if (vol->composite_id.object_id >= 1000 && vol->composite_id.object_id < 1000 + wxGetApp().plater()->get_partplate_list().get_plate_count())
                continue; // the wipe tower
            if (vol->composite_id.volume_id >= 0) {
                vol->is_active = true;
            }
        }
    }
}

References Slic3r::GLVolume::composite_id, m_render_sla_auxiliaries, m_selection, m_volumes, Slic3r::GLVolume::CompositeID::object_id, Slic3r::GUI::plater(), and Slic3r::GLVolume::CompositeID::volume_id.

Here is the call graph for this function:

◆ toggle_sla_auxiliaries_visibility()

void Slic3r::GUI::GLCanvas3D::toggle_sla_auxiliaries_visibility	(	bool	visible,
		const ModelObject *	mo = nullptr,
		int	instance_idx = -1 )

{
    if (current_printer_technology() != ptSLA)
        return;
 
    m_render_sla_auxiliaries = visible;
 
    std::vector<std::shared_ptr<SceneRaycasterItem>>* raycasters = get_raycasters_for_picking(SceneRaycaster::EType::Volume);
 
    for (GLVolume* vol : m_volumes.volumes) {
        if (vol->composite_id.object_id >= 1000 &&
            vol->composite_id.object_id < 1000 + wxGetApp().plater()->get_partplate_list().get_plate_count())
            continue; // the wipe tower
      if ((mo == nullptr || m_model->objects[vol->composite_id.object_id] == mo)
            && (instance_idx == -1 || vol->composite_id.instance_id == instance_idx)
            && vol->composite_id.volume_id < 0) {
            vol->is_active = visible;
            auto it = std::find_if(raycasters->begin(), raycasters->end(), [vol](std::shared_ptr<SceneRaycasterItem> item) { return item->get_raycaster() == vol->mesh_raycaster.get(); });
            if (it != raycasters->end())
                (*it)->set_active(vol->is_active);
        }
    }
}

References Slic3r::GLVolume::composite_id, current_printer_technology(), get_raycasters_for_picking(), Slic3r::GLVolume::CompositeID::instance_id, m_model, m_render_sla_auxiliaries, m_volumes, Slic3r::GLVolume::CompositeID::object_id, Slic3r::GUI::plater(), Slic3r::ptSLA, Slic3r::GUI::SceneRaycaster::Volume, and Slic3r::GLVolume::CompositeID::volume_id.

Referenced by Slic3r::GUI::CommonGizmosDataObjects::InstancesHider::on_update(), and toggle_model_objects_visibility().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toggle_world_axes_visibility()

void Slic3r::GUI::GLCanvas3D::toggle_world_axes_visibility ( bool force_show = false )

{
    if (force_show) {
        m_show_world_axes = true;
    } else {
        m_show_world_axes = !m_show_world_axes;
    }
    wxGetApp().app_config->set_bool("show_axes", m_show_world_axes);
    set_as_dirty();
}

References m_show_world_axes, and set_as_dirty().

Referenced by _render_canvas_toolbar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unbind_event_handlers()

void Slic3r::GUI::GLCanvas3D::unbind_event_handlers ( )

{
    if (m_canvas != nullptr && m_event_handlers_bound) {
        m_canvas->Unbind(wxEVT_SIZE, &GLCanvas3D::on_size, this);
        m_canvas->Unbind(wxEVT_IDLE, &GLCanvas3D::on_idle, this);
        m_canvas->Unbind(wxEVT_CHAR, &GLCanvas3D::on_char, this);
        m_canvas->Unbind(wxEVT_KEY_DOWN, &GLCanvas3D::on_key, this);
        m_canvas->Unbind(wxEVT_KEY_UP, &GLCanvas3D::on_key, this);
        m_canvas->Unbind(wxEVT_MOUSEWHEEL, &GLCanvas3D::on_mouse_wheel, this);
        m_canvas->Unbind(wxEVT_TIMER, &GLCanvas3D::on_timer, this);
        m_canvas->Unbind(EVT_GLCANVAS_RENDER_TIMER, &GLCanvas3D::on_render_timer, this);
        m_canvas->Unbind(wxEVT_LEFT_DOWN, &GLCanvas3D::on_mouse, this);
    m_canvas->Unbind(wxEVT_LEFT_UP, &GLCanvas3D::on_mouse, this);
        m_canvas->Unbind(wxEVT_MIDDLE_DOWN, &GLCanvas3D::on_mouse, this);
        m_canvas->Unbind(wxEVT_MIDDLE_UP, &GLCanvas3D::on_mouse, this);
        m_canvas->Unbind(wxEVT_RIGHT_DOWN, &GLCanvas3D::on_mouse, this);
        m_canvas->Unbind(wxEVT_RIGHT_UP, &GLCanvas3D::on_mouse, this);
        m_canvas->Unbind(wxEVT_MOTION, &GLCanvas3D::on_mouse, this);
        m_canvas->Unbind(wxEVT_ENTER_WINDOW, &GLCanvas3D::on_mouse, this);
        m_canvas->Unbind(wxEVT_LEAVE_WINDOW, &GLCanvas3D::on_mouse, this);
        m_canvas->Unbind(wxEVT_LEFT_DCLICK, &GLCanvas3D::on_mouse, this);
        m_canvas->Unbind(wxEVT_MIDDLE_DCLICK, &GLCanvas3D::on_mouse, this);
        m_canvas->Unbind(wxEVT_RIGHT_DCLICK, &GLCanvas3D::on_mouse, this);
        m_canvas->Unbind(wxEVT_PAINT, &GLCanvas3D::on_paint, this);
        m_canvas->Unbind(wxEVT_SET_FOCUS, &GLCanvas3D::on_set_focus, this);
        m_event_handlers_bound = false;
 
        m_canvas->Unbind(wxEVT_GESTURE_PAN, &GLCanvas3D::on_gesture, this);
        m_canvas->Unbind(wxEVT_GESTURE_ZOOM, &GLCanvas3D::on_gesture, this);
        m_canvas->Unbind(wxEVT_GESTURE_ROTATE, &GLCanvas3D::on_gesture, this);
#if __WXOSX__
        initGestures(m_canvas->GetHandle(), nullptr);
#endif
    }
}

References Slic3r::GUI::initGestures(), m_canvas, m_event_handlers_bound, on_char(), on_gesture(), on_idle(), on_key(), on_mouse(), on_mouse_wheel(), on_paint(), on_render_timer(), on_set_focus(), on_size(), and on_timer().

Here is the call graph for this function:

◆ update_compacted_wipe_tower_clearance()

void Slic3r::GUI::GLCanvas3D::update_compacted_wipe_tower_clearance ( )

{
    if (current_printer_technology() != ptFFF)
        return;
    const Print *print = fff_print();
    if (print == nullptr)
        return;
    const PrintConfig &config = print->config();
    if (config.print_sequence != PrintSequence::ByLayer || ! wipe_tower_sparse_layers_skipped(config) || ! print->has_wipe_tower())
        return;
 
    PartPlateList &plate_list = wxGetApp().plater()->get_partplate_list();
    PartPlate     *plate      = plate_list.get_curr_plate();
    if (plate == nullptr)
        return;
    const int plate_id = plate_list.get_curr_plate_index();
 
    // Once the tower has been generated the scene shows its real mesh with the brim merged in,
    // otherwise it is a bare estimated cube with no brim at all. Only the latter needs the brim added
    // here, and the width comes from WipeTowerData, the same source the preview box is sized from, so
    // the zone cannot be padded against a brim the preview was not built with.
    const bool   preview_carries_brim = print->is_step_done(psWipeTower) && print->wipe_tower_data().wipe_tower_mesh_data.has_value();
    const double brim                 = preview_carries_brim ? 0. : double(print->wipe_tower_data(print->extruders().size()).brim_width);
    const double padding              = compacted_tower_footprint_padding(config, brim);
 
    // Tower footprint straight from the volume the user sees, so that dragging either the tower or an
    // object updates the zone on the very next frame.
    Polygon tower_footprint;
    for (const GLVolume *v : m_volumes.volumes) {
        if (! v->is_wipe_tower || v->object_idx() - 1000 != plate_id)
            continue;
        const BoundingBoxf3 bbox = v->transformed_convex_hull_bounding_box();
        tower_footprint = Polygon({ Point(scale_(bbox.min.x() - padding), scale_(bbox.min.y() - padding)),
                                    Point(scale_(bbox.max.x() + padding), scale_(bbox.min.y() - padding)),
                                    Point(scale_(bbox.max.x() + padding), scale_(bbox.max.y() + padding)),
                                    Point(scale_(bbox.min.x() - padding), scale_(bbox.max.y() + padding)) });
        break;
    }
 
    const CompactedTowerZone zone = compacted_wipe_tower_zone(config, tower_footprint);
    if (zone.empty()) {
        reset_sequential_print_clearance();
        return;
    }
 
    // While dragging, outline every on-plate instance next to the tower ring, the way sequential print
    // outlines every object. Both carry half of the clearance, so the two outlines meeting is precisely
    // the moment that object goes over its limit - which is what makes the pair worth drawing at all.
    // The tier is per object, so a short object gets the narrow nozzle outline rather than the wide
    // body one it is not subject to; without that, a 3 mm object parked beside the tower would be drawn
    // deep inside the keep-out ring while passing the check. Only the instances that already exceed
    // allowed_rise also get a height limit plane.
    Polygons                               outlines;
    std::vector<std::pair<Polygon, float>> height_polygons;
    bool                                   body_tier_used = false;
    const BoundingBox                      plate_bb       = plate->get_bounding_box_crd();
    for (const ModelObject *model_object : m_model->objects) {
        for (size_t i = 0; i < model_object->instances.size(); ++i) {
            Geometry::Transformation trafo(model_object->instances[i]->get_transformation());
            const Vec3d              offset = trafo.get_offset();
            trafo.set_offset(Vec3d(offset.x(), offset.y(), 0.0));
            const Polygon inst_hull = model_object->convex_hull_2d(trafo.get_matrix());
            if (inst_hull.points.empty() || ! plate_bb.overlap(inst_hull.bounding_box()))
                continue;
 
            // Same tiers and the same rise measured from the plate as
            // Print::compacted_wipe_tower_clearance_valid(), so that the preview and the validation
            // that follows it never contradict each other.
            const double                  object_top = model_object->get_instance_max_z(i);
            const CompactedTowerClearance clearance  = compacted_wipe_tower_clearance(config, zone, inst_hull, object_top);
            body_tier_used                           = body_tier_used || compacted_tower_body_tier(clearance);
 
            const Polygon outline = compacted_wipe_tower_offender_outline(inst_hull, clearance.body_clearance);
            outlines.emplace_back(outline);
            if (object_top <= clearance.allowed_rise + EPSILON)
                continue;
            height_polygons.emplace_back(outline, float(clearance.allowed_rise));
        }
    }
 
    Polygons polygons = compacted_wipe_tower_rings(zone, body_tier_used);
    append(polygons, outlines);
 
    set_sequential_print_clearance_visible(true);
    set_sequential_print_clearance_render_fill(false);
    set_sequential_print_clearance_polygons(polygons, height_polygons);
}

References Slic3r::CompactedTowerClearance::allowed_rise, Slic3r::append(), Slic3r::CompactedTowerClearance::body_clearance, Slic3r::MultiPoint::bounding_box(), Slic3r::WipeTowerData::brim_width, Slic3r::ByLayer, Slic3r::compacted_tower_body_tier(), Slic3r::compacted_tower_footprint_padding(), Slic3r::compacted_wipe_tower_clearance(), Slic3r::compacted_wipe_tower_offender_outline(), Slic3r::compacted_wipe_tower_rings(), Slic3r::compacted_wipe_tower_zone(), Slic3r::Print::config(), Slic3r::ModelObject::convex_hull_2d(), current_printer_technology(), Slic3r::CompactedTowerZone::empty(), EPSILON, Slic3r::Print::extruders(), fff_print(), Slic3r::GUI::PartPlate::get_bounding_box_crd(), Slic3r::GUI::PartPlateList::get_curr_plate(), Slic3r::GUI::PartPlateList::get_curr_plate_index(), Slic3r::ModelObject::get_instance_max_z(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::Print::has_wipe_tower(), Slic3r::ModelObject::instances, Slic3r::Print::is_step_done(), m_model, m_volumes, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::GLVolume::object_idx(), Slic3r::offset(), Slic3r::BoundingBoxBase< PointType, APointsType >::overlap(), Slic3r::MultiPoint::points, Slic3r::psWipeTower, Slic3r::ptFFF, reset_sequential_print_clearance(), scale_, Slic3r::Geometry::Transformation::set_offset(), set_sequential_print_clearance_polygons(), set_sequential_print_clearance_render_fill(), set_sequential_print_clearance_visible(), Slic3r::GLVolume::transformed_convex_hull_bounding_box(), Slic3r::Print::wipe_tower_data(), Slic3r::WipeTowerData::wipe_tower_mesh_data, and Slic3r::wipe_tower_sparse_layers_skipped().

Referenced by on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_gcode_sequential_view_current()

void Slic3r::GUI::GLCanvas3D::update_gcode_sequential_view_current	(	unsigned int	first,
		unsigned int	last )

inline

1011{ m_gcode_viewer.update_sequential_view_current(first, last); }

References m_gcode_viewer.

◆ update_gizmos_on_off_state()

void Slic3r::GUI::GLCanvas3D::update_gizmos_on_off_state ( )

{
    set_as_dirty();
    m_gizmos.update_data();
    m_gizmos.refresh_on_off_state();
}

References m_gizmos, and set_as_dirty().

Here is the call graph for this function:

◆ update_instance_printable_state_for_object()

void Slic3r::GUI::GLCanvas3D::update_instance_printable_state_for_object ( size_t obj_idx )

{
    ModelObject* model_object = m_model->objects[obj_idx];
    for (int inst_idx = 0; inst_idx < (int)model_object->instances.size(); ++inst_idx) {
        ModelInstance* instance = model_object->instances[inst_idx];
 
        for (GLVolume* volume : m_volumes.volumes) {
            if ((volume->object_idx() == (int)obj_idx) && (volume->instance_idx() == inst_idx))
                volume->printable = instance->printable;
                if (!volume->printable) {
                    volume->render_color = GLVolume::UNPRINTABLE_COLOR;
                }
        }
    }
}

References Slic3r::GLVolume::instance_idx(), Slic3r::ModelObject::instances, m_model, m_volumes, Slic3r::GLVolume::object_idx(), Slic3r::ModelInstance::printable, Slic3r::GLVolume::render_color, and Slic3r::GLVolume::UNPRINTABLE_COLOR.

Referenced by anonymous_namespace{EmbossJob.cpp}::create_volume(), and update_instance_printable_state_for_objects().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_instance_printable_state_for_objects()

void Slic3r::GUI::GLCanvas3D::update_instance_printable_state_for_objects ( const std::vector< size_t > & object_idxs )

{
    for (size_t obj_idx : object_idxs)
        update_instance_printable_state_for_object(obj_idx);
}

References update_instance_printable_state_for_object().

Here is the call graph for this function:

◆ update_render_colors()

void Slic3r::GUI::GLCanvas3D::update_render_colors ( )

staticprivate

{
    DEFAULT_BG_LIGHT_COLOR = ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_3D_Background]);
}

References Slic3r::RenderColor::colors, DEFAULT_BG_LIGHT_COLOR, Slic3r::GUI::ImGuiWrapper::from_ImVec4(), and RenderCol_3D_Background.

Referenced by _render_style_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_sequential_clearance()

void Slic3r::GUI::GLCanvas3D::update_sequential_clearance ( )

{
    if (current_printer_technology() != ptFFF || (fff_print()->config().print_sequence == PrintSequence::ByLayer))
        return;
 
    if (m_gizmos.is_dragging())
        return;
 
    // collects instance transformations from volumes
    // first define temporary cache
    unsigned int instances_count = 0;
    std::vector<std::vector<std::optional<Geometry::Transformation>>> instance_transforms;
    for (size_t obj = 0; obj < m_model->objects.size(); ++obj) {
        instance_transforms.emplace_back(std::vector<std::optional<Geometry::Transformation>>());
        const ModelObject* model_object = m_model->objects[obj];
        for (size_t i = 0; i < model_object->instances.size(); ++i) {
            instance_transforms[obj].emplace_back(std::optional<Geometry::Transformation>());
            ++instances_count;
        }
    }
 
    //if (instances_count == 1)
    //    return;
 
    // second fill temporary cache with data from volumes
    for (const GLVolume* v : m_volumes.volumes) {
        if (v->is_modifier || v->is_wipe_tower)
            continue;
 
        auto& transform = instance_transforms[v->object_idx()][v->instance_idx()];
        if (!transform.has_value())
            transform = v->get_instance_transformation();
    }
 
    // calculates objects 2d hulls (see also: Print::sequential_print_horizontal_clearance_valid())
    // this is done only the first time this method is called while moving the mouse,
    // the results are then cached for following displacements
    if (m_sequential_print_clearance_first_displacement) {
        m_sequential_print_clearance.m_hull_2d_cache.clear();
        auto [object_skirt_offset, _] = fff_print()->object_skirt_offset();
        float shrink_factor;
        if (fff_print()->is_all_objects_are_short())
            shrink_factor = scale_(std::max(0.5f * MAX_OUTER_NOZZLE_DIAMETER, object_skirt_offset) - 0.1);
        else
            shrink_factor = static_cast<float>(scale_(0.5 * fff_print()->config().extruder_clearance_radius.value + object_skirt_offset - 0.1));
 
        double mitter_limit = scale_(0.1);
        m_sequential_print_clearance.m_hull_2d_cache.reserve(m_model->objects.size());
        for (size_t i = 0; i < m_model->objects.size(); ++i) {
            ModelObject* model_object = m_model->objects[i];
            ModelInstance* model_instance0 = model_object->instances.front();
            Polygon hull_no_offset = model_object->convex_hull_2d(Geometry::assemble_transform({ 0.0, 0.0, model_instance0->get_offset().z() }, model_instance0->get_rotation(),
                model_instance0->get_scaling_factor(), model_instance0->get_mirror()));
            auto tmp = offset(hull_no_offset,
                // Shrink the extruder_clearance_radius a tiny bit, so that if the object arrangement algorithm placed the objects
                // exactly by satisfying the extruder_clearance_radius, this test will not trigger collision.
                shrink_factor,
                jtRound, mitter_limit);
            Polygon hull_2d = !tmp.empty() ? tmp.front() : hull_no_offset;// tmp may be empty due to clipper's bug, see STUDIO-2452
 
            Pointf3s& cache_hull_2d = m_sequential_print_clearance.m_hull_2d_cache.emplace_back(Pointf3s());
            cache_hull_2d.reserve(hull_2d.points.size());
            for (const Point& p : hull_2d.points) {
                cache_hull_2d.emplace_back(unscale<double>(p.x()), unscale<double>(p.y()), 0.0);
            }
        }
        m_sequential_print_clearance_first_displacement = false;
    }
 
    // calculates instances 2d hulls (see also: Print::sequential_print_horizontal_clearance_valid())
    //BBS: add the height logic
    PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
    Polygons polygons;
    polygons.reserve(instances_count);
    std::vector<SequentialClearanceInstance> convex_and_bounding_boxes;
    convex_and_bounding_boxes.reserve(instances_count);
    std::map<ObjectID, int> print_order;
    for (const PrintObject* print_object : fff_print()->objects())
        for (const PrintInstance& instance : print_object->instances())
            print_order.emplace(instance.model_instance->id(), instance.model_instance->arrange_order);
 
    for (size_t i = 0; i < instance_transforms.size(); ++i) {
        const size_t first_instance = convex_and_bounding_boxes.size();
        const auto& instances = instance_transforms[i];
        double rotation_z0 = instances.front()->get_rotation().z();
        int index = 0;
        for (const auto& instance : instances) {
            Geometry::Transformation transformation;
            const Vec3d& offset = instance->get_offset();
            transformation.set_offset({ offset.x(), offset.y(), 0.0 });
            transformation.set_rotation(Z, instance->get_rotation().z() - rotation_z0);
            const Transform3d& trafo = transformation.get_matrix();
            const Pointf3s& hull_2d = m_sequential_print_clearance.m_hull_2d_cache[i];
            Points inst_pts;
            inst_pts.reserve(hull_2d.size());
            for (size_t j = 0; j < hull_2d.size(); ++j) {
                const Vec3d p = trafo * hull_2d[j];
                inst_pts.emplace_back(scaled<double>(p.x()), scaled<double>(p.y()));
            }
            Polygon convex_hull(std::move(inst_pts));
            BoundingBox bouding_box = convex_hull.bounding_box();
            BoundingBox plate_bb = plate->get_bounding_box_crd();
            const ObjectID instance_id = m_model->objects[i]->instances[index]->id();
            double instance_height = m_model->objects[i]->get_instance_max_z(index++);
            //skip the object for not current plate
            if (!plate_bb.overlap(bouding_box))
                continue;
            convex_and_bounding_boxes.push_back({instance_height, bouding_box, convex_hull, instance_id});
            polygons.emplace_back(std::move(convex_hull));
        }
        sort_sequential_clearance_instances(convex_and_bounding_boxes.begin() + first_instance, convex_and_bounding_boxes.end(), print_order);
    }
 
    const auto& config = fff_print()->config();
    const auto height_polygons = sequential_clearance_height_polygons(convex_and_bounding_boxes, config.printable_height,
        config.extruder_clearance_height_to_lid, config.extruder_clearance_height_to_rod);
 
    // sends instances 2d hulls to be rendered
    set_sequential_print_clearance_visible(true);
    set_sequential_print_clearance_render_fill(false);
    set_sequential_print_clearance_polygons(polygons, height_polygons);
}

References _, Slic3r::Geometry::assemble_transform(), Slic3r::ByLayer, Slic3r::Print::config(), Slic3r::Geometry::convex_hull(), Slic3r::ModelObject::convex_hull_2d(), current_printer_technology(), Slic3r::MultiPoint::empty(), fff_print(), Slic3r::GUI::PartPlate::get_bounding_box_crd(), Slic3r::GLVolume::get_instance_transformation(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelInstance::get_mirror(), Slic3r::ModelInstance::get_offset(), Slic3r::ModelInstance::get_rotation(), Slic3r::ModelInstance::get_scaling_factor(), Slic3r::GLVolume::instance_idx(), Slic3r::ModelObject::instances, Slic3r::jtRound, m_gizmos, m_model, m_sequential_print_clearance, m_sequential_print_clearance_first_displacement, m_volumes, MAX_OUTER_NOZZLE_DIAMETER, Slic3r::GLVolume::object_idx(), Slic3r::Print::object_skirt_offset(), Slic3r::offset(), Slic3r::BoundingBoxBase< PointType, APointsType >::overlap(), Slic3r::MultiPoint::points, Slic3r::print_sequence(), Slic3r::ptFFF, scale_, Slic3r::scaled(), Slic3r::GUI::sequential_clearance_height_polygons(), Slic3r::Geometry::Transformation::set_offset(), Slic3r::Geometry::Transformation::set_rotation(), set_sequential_print_clearance_polygons(), set_sequential_print_clearance_render_fill(), set_sequential_print_clearance_visible(), Slic3r::GUI::sort_sequential_clearance_instances(), Slic3r::transform(), Slic3r::unscale(), and Slic3r::Z.

Referenced by on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_shortcut_tooltips()

void Slic3r::GUI::GLCanvas3D::update_shortcut_tooltips ( )

{
    const ShortcutRegistry& shortcuts = wxGetApp().shortcuts();
    m_main_toolbar.set_tooltip(m_main_toolbar.get_item_id("add"), shortcuts.with_key(_u8L("Add"), Shortcut::ImportModel));
    m_main_toolbar.set_tooltip(m_main_toolbar.get_item_id("orient"), shortcuts.with_key(_u8L("Auto orient all/selected objects"), Shortcut::Orient) + "\n" + shortcuts.with_key(_u8L("Auto orient all objects on current plate"), Shortcut::OrientPlate));
    m_main_toolbar.set_tooltip(m_main_toolbar.get_item_id("arrange"), shortcuts.with_key(_u8L("Arrange all objects"), Shortcut::Arrange) + "\n" + shortcuts.with_key(_u8L("Arrange objects on selected plates"), Shortcut::ArrangePlate));
    m_main_toolbar.set_tooltip(m_main_toolbar.get_item_id("more"), shortcuts.with_key(_u8L("Add instance"), Shortcut::AddInstance));
    m_main_toolbar.set_tooltip(m_main_toolbar.get_item_id("fewer"), shortcuts.with_key(_u8L("Remove instance"), Shortcut::RemoveInstance));
}

References _u8L, Slic3r::GUI::AddInstance, Slic3r::GUI::Arrange, Slic3r::GUI::ArrangePlate, Slic3r::GUI::ImportModel, m_main_toolbar, Slic3r::GUI::Orient, Slic3r::GUI::OrientPlate, Slic3r::GUI::RemoveInstance, and Slic3r::GUI::ShortcutRegistry::with_key().

Referenced by _init_main_toolbar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_ui_from_settings()

void Slic3r::GUI::GLCanvas3D::update_ui_from_settings ( )

{
    m_dirty = true;
 
#if __APPLE__
    // Update OpenGL scaling on OSX after the user toggled the "use_retina_opengl" settings in Preferences dialog.
    const float orig_scaling = m_retina_helper->get_scale_factor();
 
    const bool use_retina = true;
    BOOST_LOG_TRIVIAL(debug) << "GLCanvas3D: Use Retina OpenGL: " << use_retina;
    m_retina_helper->set_use_retina(use_retina);
    const float new_scaling = m_retina_helper->get_scale_factor();
 
    if (new_scaling != orig_scaling) {
        BOOST_LOG_TRIVIAL(debug) << "GLCanvas3D: Scaling factor: " << new_scaling;
 
        Camera& camera = wxGetApp().plater()->get_camera();
        camera.set_zoom(camera.get_zoom() * new_scaling / orig_scaling);
        _refresh_if_shown_on_screen();
    }
#endif // ENABLE_RETINA_GL
}

References _refresh_if_shown_on_screen(), camera, and m_dirty.

Here is the call graph for this function:

◆ update_volumes_colors_by_extruder()

void Slic3r::GUI::GLCanvas3D::update_volumes_colors_by_extruder ( )

{
    if (m_config != nullptr)
        m_volumes.update_colors_by_extruder(m_config);
}

References m_config, and m_volumes.

Referenced by _load_sla_shells(), and reload_scene().

Here is the caller graph for this function:

◆ use_slope()

void Slic3r::GUI::GLCanvas3D::use_slope ( bool use )

inline

1409{ m_slope.use(use); }

References m_slope.

◆ volumes_bounding_box()

BoundingBoxf3 Slic3r::GUI::GLCanvas3D::volumes_bounding_box ( bool current_plate_only = false ) const

{
    BoundingBoxf3 bb;
    BoundingBoxf3 expand_part_plate_list_box;
    bool          is_limit = m_canvas_type != ECanvasType::CanvasAssembleView;
    if (is_limit) {
        if (current_plate_only) {
            expand_part_plate_list_box = _current_plate_box();
        } else {
            auto        plate_list_box = wxGetApp().plater()->get_partplate_list().get_bounding_box();
            auto        horizontal_radius = 0.5 * sqrt(std::pow(plate_list_box.min[0] - plate_list_box.max[0], 2) + std::pow(plate_list_box.min[1] - plate_list_box.max[1], 2));
            const float scale             = 2;
            expand_part_plate_list_box.merge(plate_list_box.min - scale * Vec3d(horizontal_radius, horizontal_radius, 0));
            expand_part_plate_list_box.merge(plate_list_box.max + scale * Vec3d(horizontal_radius, horizontal_radius, 0));
        }
    }
    for (const GLVolume *volume : m_volumes.volumes) {
        if (!m_apply_zoom_to_volumes_filter || ((volume != nullptr) && volume->zoom_to_volumes)) {
            const auto v_bb     = volume->transformed_bounding_box();
            if (is_limit && !expand_part_plate_list_box.overlap(v_bb))
                continue;
            bb.merge(v_bb);
        }
    }
    return bb;
}

References _current_plate_box(), CanvasAssembleView, m_apply_zoom_to_volumes_filter, m_canvas_type, m_volumes, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::overlap(), scale(), and Slic3r::GLVolume::transformed_bounding_box().

Referenced by _get_section_view_plane(), _max_bounding_box(), get_camera_orbit_target(), Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::on_timer(), scene_bounding_box(), and zoom_to_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ zoom_to_bed()

void Slic3r::GUI::GLCanvas3D::zoom_to_bed ( )

{
    BoundingBoxf3 box = m_bed.build_volume().bounding_volume();
    box.min.z() = 0.0;
    box.max.z() = 0.0;
    _zoom_to_box(box, DefaultCameraZoomToBedMarginFactor);
}

References _zoom_to_box(), DefaultCameraZoomToBedMarginFactor, m_bed, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, and Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min.

Referenced by _render_canvas_toolbar(), _render_frame(), _render_imgui_select_plate_toolbar(), and Slic3r::GUI::MainFrame::add_common_view_menu_items().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ zoom_to_gcode()

void Slic3r::GUI::GLCanvas3D::zoom_to_gcode ( )

{
    _zoom_to_box(m_gcode_viewer.get_paths_bounding_box(), 1.05);
}

References _zoom_to_box(), and m_gcode_viewer.

Here is the call graph for this function:

◆ zoom_to_plate()

void Slic3r::GUI::GLCanvas3D::zoom_to_plate ( int plate_idx = -1 )

{
    BoundingBoxf3 box;
    if (plate_idx == REQUIRES_ZOOM_TO_ALL_PLATE && _hides_inactive_plates())
        plate_idx = REQUIRES_ZOOM_TO_CUR_PLATE;
    if (plate_idx == REQUIRES_ZOOM_TO_ALL_PLATE) {
        box = wxGetApp().plater()->get_partplate_list().get_bounding_box();
        box.min.z() = 0.0;
        box.max.z() = 0.0;
        _zoom_to_box(box, DefaultCameraZoomToPlateMarginFactor);
    } else {
        PartPlate* plate = nullptr;
        if (plate_idx == REQUIRES_ZOOM_TO_CUR_PLATE) {
            plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
        }else {
            assert(plate_idx >= 0 && plate_idx < wxGetApp().plater()->get_partplate_list().get_plate_count());
            plate = wxGetApp().plater()->get_partplate_list().get_plate(plate_idx);
        }
        box = plate->get_bounding_box(true);
        box.min.z() = 0.0;
        box.max.z() = 0.0;
        _zoom_to_box(box, DefaultCameraZoomToPlateMarginFactor);
    }
}

References _hides_inactive_plates(), _zoom_to_box(), DefaultCameraZoomToPlateMarginFactor, Slic3r::GUI::PartPlate::get_bounding_box(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::GUI::plater(), REQUIRES_ZOOM_TO_ALL_PLATE, and REQUIRES_ZOOM_TO_CUR_PLATE.

Referenced by _render_canvas_toolbar(), and _render_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ zoom_to_selection()

void Slic3r::GUI::GLCanvas3D::zoom_to_selection ( )

{
    if (!m_selection.is_empty())
        _zoom_to_box(m_selection.get_bounding_box());
}

References _zoom_to_box(), and m_selection.

Referenced by _render_canvas_toolbar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ zoom_to_volumes()

void Slic3r::GUI::GLCanvas3D::zoom_to_volumes ( )

{
    m_apply_zoom_to_volumes_filter = true;
    _zoom_to_box(volumes_bounding_box());
    m_apply_zoom_to_volumes_filter = false;
}

References _zoom_to_box(), m_apply_zoom_to_volumes_filter, and volumes_bounding_box().

Referenced by _render_canvas_toolbar(), _render_frame(), and Slic3r::GUI::DesignSketchTool::on_mouse_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ assembly_view_count

int Slic3r::GUI::GLCanvas3D::assembly_view_count = 0

private

◆ auto_arrange_count

int Slic3r::GUI::GLCanvas3D::auto_arrange_count = 0

private

◆ auto_orient_count

int Slic3r::GUI::GLCanvas3D::auto_orient_count = 0

private

Referenced by _init_main_toolbar().

◆ camera

Camera Slic3r::GUI::GLCanvas3D::camera

private

◆ custom_height_count

int Slic3r::GUI::GLCanvas3D::custom_height_count = 0

private

◆ DefaultCameraZoomToBedMarginFactor

const double Slic3r::GUI::GLCanvas3D::DefaultCameraZoomToBedMarginFactor = 2.00

staticprivate

Referenced by Slic3r::GUI::wxDEFINE_EVENT(), and zoom_to_bed().

◆ DefaultCameraZoomToBoxMarginFactor

const double Slic3r::GUI::GLCanvas3D::DefaultCameraZoomToBoxMarginFactor = 1.25

staticprivate

Referenced by Slic3r::GUI::wxDEFINE_EVENT().

◆ DefaultCameraZoomToPlateMarginFactor

const double Slic3r::GUI::GLCanvas3D::DefaultCameraZoomToPlateMarginFactor = 1.25

staticprivate

Referenced by Slic3r::GUI::wxDEFINE_EVENT(), and zoom_to_plate().

◆ m_alt_wheel_used

bool Slic3r::GUI::GLCanvas3D::m_alt_wheel_used { false }

private

722{ false };

Referenced by on_key(), and on_mouse_wheel().

◆ m_apply_zoom_to_volumes_filter

bool Slic3r::GUI::GLCanvas3D::m_apply_zoom_to_volumes_filter

private

Referenced by GLCanvas3D(), volumes_bounding_box(), and zoom_to_volumes().

◆ m_arrange_settings_fff

ArrangeSettings Slic3r::GUI::GLCanvas3D::m_arrange_settings_fff

private

Referenced by get_arrange_settings(), and load_arrange_settings().

◆ m_arrange_settings_fff_seq_print

ArrangeSettings Slic3r::GUI::GLCanvas3D::m_arrange_settings_fff_seq_print

private

Referenced by get_arrange_settings(), and load_arrange_settings().

◆ m_arrange_settings_sla

ArrangeSettings Slic3r::GUI::GLCanvas3D::m_arrange_settings_sla

private

Referenced by get_arrange_settings(), and load_arrange_settings().

◆ m_assemble_view_toolbar

GLToolbar Slic3r::GUI::GLCanvas3D::m_assemble_view_toolbar

mutableprivate

Referenced by GLCanvas3D(), _check_and_update_toolbar_icon_scale(), _init_assemble_view_toolbar(), _overlay_signature(), _render_assemble_view_toolbar(), _render_fps_overlay(), _render_frame(), _switch_toolbars_icon_filename(), enable_assemble_view_toolbar(), get_assemble_view_toolbar_height(), get_assemble_view_toolbar_width(), get_main_toolbar_offset(), on_change_color_mode(), on_idle(), and on_mouse().

◆ m_axes

Bed3D::Axes Slic3r::GUI::GLCanvas3D::m_axes

private

◆ m_background

GLModel Slic3r::GUI::GLCanvas3D::m_background

Referenced by _render_background(), _render_frame(), _render_fxaa_pass(), and _render_ssao_pass().

◆ m_bed

Bed3D& Slic3r::GUI::GLCanvas3D::m_bed

private

Referenced by GLCanvas3D(), _current_plate_box(), _max_bounding_box(), _render_bed(), _render_cad_grid(), _render_frame(), _render_objects(), _render_shadows(), check_volumes_outside_state(), get_size_proportional_to_max_bed_size(), on_change_color_mode(), reload_scene(), scene_bounding_box(), and zoom_to_bed().

◆ m_benchmarking

bool Slic3r::GUI::GLCanvas3D::m_benchmarking { false }

private

806{ false };

Referenced by _is_fps_overlay_enabled(), _is_render_timings_enabled(), _render_frame(), on_idle(), and set_benchmarking().

◆ m_cad_grid_bb

BoundingBoxf Slic3r::GUI::GLCanvas3D::m_cad_grid_bb

private

Referenced by _render_cad_grid().

◆ m_cad_grid_center

Vec2d Slic3r::GUI::GLCanvas3D::m_cad_grid_center

private

Referenced by _render_cad_grid().

◆ m_cad_grid_major

GLModel Slic3r::GUI::GLCanvas3D::m_cad_grid_major

private

Referenced by _render_cad_grid().

◆ m_cad_grid_minor

GLModel Slic3r::GUI::GLCanvas3D::m_cad_grid_minor

private

Referenced by _render_cad_grid().

◆ m_cad_grid_valid

bool Slic3r::GUI::GLCanvas3D::m_cad_grid_valid {false}

private

697{false};

Referenced by _render_cad_grid().

◆ m_camera_clipping_plane

ClippingPlane Slic3r::GUI::GLCanvas3D::m_camera_clipping_plane

private

Referenced by _render_objects().

◆ m_camera_movement

bool Slic3r::GUI::GLCanvas3D::m_camera_movement

private

Referenced by GLCanvas3D(), mouse_up_cleanup(), on_key(), and on_mouse().

◆ m_canvas

◆ m_canvas_toolbar_pos

Vec2i32 Slic3r::GUI::GLCanvas3D::m_canvas_toolbar_pos = {140, 5}

mutableprivate

669{140, 5};

Referenced by _render_3d_navigator(), and _render_canvas_toolbar().

◆ m_canvas_type

ECanvasType Slic3r::GUI::GLCanvas3D::m_canvas_type

private

◆ m_center_of_mass

CenterOfMass Slic3r::GUI::GLCanvas3D::m_center_of_mass

private

Referenced by _render_overlays(), _render_scene(), and on_mouse().

◆ m_clipping_planes

std::array<ClippingPlane, 2> Slic3r::GUI::GLCanvas3D::m_clipping_planes

private

Referenced by _render_objects(), _render_sla_slices(), get_clipping_planes(), and set_clipping_plane().

◆ m_collapse_side

std::function<CollapseSide()> Slic3r::GUI::GLCanvas3D::m_collapse_side

private

Referenced by collapse_side(), and set_collapse_toolbar().

◆ m_collapse_toolbar

GLToolbar* Slic3r::GUI::GLCanvas3D::m_collapse_toolbar {nullptr}

private

674{nullptr};

Referenced by _init_collapse_toolbar(), collapse_toolbar(), and set_collapse_toolbar().

◆ m_collapse_toolbar_enabled

bool Slic3r::GUI::GLCanvas3D::m_collapse_toolbar_enabled {true}

private

672{true};

Referenced by _render_collapse_toolbar(), and enable_collapse_toolbar().

◆ m_color_by

std::string Slic3r::GUI::GLCanvas3D::m_color_by

private

Referenced by GLCanvas3D(), load_object(), reload_scene(), and set_color_by().

◆ m_config

const DynamicPrintConfig* Slic3r::GUI::GLCanvas3D::m_config

private

Referenced by GLCanvas3D(), _get_current_partplate_print_volume(), load_shells(), plate_scene_bounding_box(), reload_scene(), set_config(), and update_volumes_colors_by_extruder().

◆ m_context

wxGLContext* Slic3r::GUI::GLCanvas3D::m_context

private

Referenced by GLCanvas3D(), _resize(), _set_current(), init(), and set_context().

◆ m_cursor_type

ECursorType Slic3r::GUI::GLCanvas3D::m_cursor_type

private

Referenced by GLCanvas3D(), and set_cursor().

◆ m_design_canvas

bool Slic3r::GUI::GLCanvas3D::m_design_canvas {false}

private

681{false};

Referenced by _current_plate_box(), _hides_inactive_plates(), _render_bed(), _render_canvas_toolbar(), _render_platelist(), _render_scene(), Slic3r::GUI::GLCanvas3D::CenterOfMass::render(), and set_design_canvas().

◆ m_dirty

bool Slic3r::GUI::GLCanvas3D::m_dirty

private

◆ m_dynamic_background_enabled

bool Slic3r::GUI::GLCanvas3D::m_dynamic_background_enabled

private

Referenced by GLCanvas3D(), _render_background(), and enable_dynamic_background().

◆ m_enable_render

bool Slic3r::GUI::GLCanvas3D::m_enable_render { true }

private

751{ true };

Referenced by _render_frame(), enable_render(), and is_rendering_enabled().

◆ m_event_handlers_bound

bool Slic3r::GUI::GLCanvas3D::m_event_handlers_bound { false }

private

728{ false };

Referenced by bind_event_handlers(), and unbind_event_handlers().

◆ m_explosion_ratio

float Slic3r::GUI::GLCanvas3D::m_explosion_ratio = 1.0

mutableprivate

Referenced by _render_assemble_control(), get_explosion_ratio(), on_mouse_wheel(), and reset_explosion_ratio().

◆ m_extra_frame_requested

bool Slic3r::GUI::GLCanvas3D::m_extra_frame_requested

private

Referenced by GLCanvas3D(), on_idle(), and request_extra_frame().

◆ m_fps_overlay_tick

bool Slic3r::GUI::GLCanvas3D::m_fps_overlay_tick { false }

private

653{ false };

Referenced by _render_frame(), and on_fps_overlay_timer().

◆ m_fps_overlay_timer

wxTimer Slic3r::GUI::GLCanvas3D::m_fps_overlay_timer

private

Referenced by GLCanvas3D(), and _render_frame().

◆ m_frame_profiler

FrameProfiler Slic3r::GUI::GLCanvas3D::m_frame_profiler

private

Referenced by ~GLCanvas3D(), _render_fps_overlay(), _render_frame(), _render_scene(), and get_frame_profiler().

◆ m_fxaa_texture_id

unsigned int Slic3r::GUI::GLCanvas3D::m_fxaa_texture_id { 0 }

922{ 0 };

Referenced by ~GLCanvas3D(), and _render_fxaa_pass().

◆ m_fxaa_texture_size

std::array<unsigned int, 2> Slic3r::GUI::GLCanvas3D::m_fxaa_texture_size { 0, 0 }

923{ 0, 0 };

Referenced by _render_fxaa_pass().

◆ m_gcode_layers_times_cache

std::vector<float> Slic3r::GUI::GLCanvas3D::m_gcode_layers_times_cache

private

Referenced by get_gcode_layers_times_cache(), load_gcode_preview(), and reset_gcode_layers_times_cache().

◆ m_gcode_viewer

GCodeViewer Slic3r::GUI::GLCanvas3D::m_gcode_viewer

private

Referenced by _check_and_update_toolbar_icon_scale(), _get_section_view_plane(), _max_bounding_box(), _render_background(), _render_canvas_toolbar(), _render_frame(), _render_gcode(), _render_gcode_overlay(), _render_gcode_translucent(), _render_imgui_select_plate_toolbar(), _render_scene(), _render_shadows(), _set_warning_notification(), _set_warning_notification_if_needed(), _shadow_casters_signature(), export_toolpaths_to_obj(), get_gcode_extruders_count(), get_gcode_layers_times(), get_gcode_layers_zs(), get_gcode_sequential_view(), get_gcode_vertex_at(), get_gcode_view_enabled_range(), get_gcode_view_full_range(), get_gcode_view_type(), get_gcode_view_visible_range(), get_gcode_viewer(), handle_shortcut(), has_toolpaths_to_export(), init_gcode_viewer(), load_gcode_preview(), load_shells(), msw_rescale(), on_change_color_mode(), reset_gcode_toolpaths(), reset_shells(), set_gcode_view_type(), set_shell_transparence(), set_shells_on_previewing(), update_gcode_sequential_view_current(), and zoom_to_gcode().

◆ m_gesture_pan_anchor

std::optional<Vec3d> Slic3r::GUI::GLCanvas3D::m_gesture_pan_anchor

private

Referenced by on_gesture().

◆ m_gizmo_highlighter

struct Slic3r::GUI::GLCanvas3D::GizmoHighlighter Slic3r::GUI::GLCanvas3D::m_gizmo_highlighter

Referenced by _render_gizmos_overlay(), bind_event_handlers(), and highlight_gizmo().

◆ m_gizmos

GLGizmosManager Slic3r::GUI::GLCanvas3D::m_gizmos

private

Referenced by GLCanvas3D(), _check_and_update_toolbar_icon_scale(), _get_volumes_clipping_plane(), _init_main_toolbar(), _is_below_plate_view_active(), _is_scene_cacheable(), _is_xray_view_active(), _max_bounding_box(), _on_section_view_changed(), _overlay_signature(), _picking_pass(), _picking_pass_imex_ghosts(), _rectangular_selection_picking_pass(), _render_3d_navigator(), _render_assemble_control(), _render_assemble_view_toolbar(), _render_canvas_toolbar(), _render_current_gizmo(), _render_fps_overlay(), _render_frame(), _render_gizmos_overlay(), _render_objects(), _render_overlays(), _render_plate_switcher(), _render_return_toolbar(), _render_scene(), _render_section_view_caps(), _render_selection(), _render_selection_sidebar_hints(), _render_separator_toolbar_right(), _render_sequential_clearance(), _scene_cache_key(), _update_inactive_plates_visibility(), _update_selection_from_hover(), can_sequential_clearance_show_in_gizmo(), deselect_all(), enable_gizmos(), exit_gizmo(), finish_selection_edit(), get_camera_orbit_target(), get_gizmos_manager(), get_gizmos_manager(), get_main_toolbar_offset(), get_raycaster_clipping_plane(), handle_layers_data_focus_event(), handle_shortcut(), highlight_gizmo(), init(), is_dragging(), on_change_color_mode(), on_char(), on_key(), on_mouse(), on_mouse_wheel(), on_set_color_timer(), reload_scene(), reset_all_gizmos(), select_all(), update_gizmos_on_off_state(), and update_sequential_clearance().

◆ m_hover_ghost_head

int Slic3r::GUI::GLCanvas3D::m_hover_ghost_head { -1 }

private

788{ -1 }; // physical head index, -1 when not hovering a ghost

Referenced by _picking_pass_imex_ghosts(), _render_frame(), _render_imex_ghost_tooltip(), get_hover_ghost_head(), and on_mouse().

◆ m_hover_ghost_plate

int Slic3r::GUI::GLCanvas3D::m_hover_ghost_plate { -1 }

private

789{ -1 }; // plate index for the hovered ghost, -1 when none

Referenced by _picking_pass_imex_ghosts(), _render_imex_ghost_tooltip(), and get_hover_ghost_plate().

◆ m_hover_plate_idxs

std::vector<int> Slic3r::GUI::GLCanvas3D::m_hover_plate_idxs

private

Referenced by _picking_pass(), _render_scene(), _scene_cache_key(), GetHoverId(), and on_mouse().

◆ m_hover_volume_idxs

std::vector<int> Slic3r::GUI::GLCanvas3D::m_hover_volume_idxs

mutableprivate

Referenced by _picking_pass(), _update_selection_from_hover(), _update_volumes_hover_state(), enable_picking(), get_first_hover_volume_idx(), on_mouse(), and reload_scene().

◆ m_imgui_undo_redo_hovered_pos

int Slic3r::GUI::GLCanvas3D::m_imgui_undo_redo_hovered_pos { -1 }

private

809{ -1 };

◆ m_in_render

bool Slic3r::GUI::GLCanvas3D::m_in_render

private

Referenced by GLCanvas3D(), _render_frame(), and schedule_extra_frame().

◆ m_inactive_plates_hidden

bool Slic3r::GUI::GLCanvas3D::m_inactive_plates_hidden { false }

private

786{ false };

Referenced by _update_inactive_plates_visibility().

◆ m_initialized

bool Slic3r::GUI::GLCanvas3D::m_initialized

private

Referenced by GLCanvas3D(), check_volumes_outside_state(), init(), is_initialized(), load_object(), load_shells(), on_char(), on_gesture(), on_idle(), on_mouse(), on_mouse_wheel(), on_paint(), reload_scene(), and reset_volumes().

◆ m_is_dark

bool Slic3r::GUI::GLCanvas3D::m_is_dark = false

private

Referenced by _init_assemble_view_toolbar(), _init_collapse_toolbar(), _init_main_toolbar(), _init_select_plate_toolbar(), _init_separator_toolbar(), _render_3d_navigator(), _render_background(), _render_canvas_toolbar(), _render_imgui_select_plate_toolbar(), _render_paint_toolbar(), _render_plate_switcher(), _render_return_toolbar(), _render_section_view_panel(), _switch_toolbars_icon_filename(), get_dark_mode_status(), and on_change_color_mode().

◆ m_is_touchpad_navigation

bool Slic3r::GUI::GLCanvas3D::m_is_touchpad_navigation { false }

private

743{ false };

Referenced by is_camera_pan(), is_camera_rotate(), on_key(), and on_set_focus().

◆ m_key_down

KeyDown Slic3r::GUI::GLCanvas3D::m_key_down

private

Referenced by handle_shortcut(), and on_key().

◆ m_labels

Labels Slic3r::GUI::GLCanvas3D::m_labels

private

Referenced by GLCanvas3D(), _render_overlays(), are_labels_shown(), enable_labels(), init(), and show_labels().

◆ m_last_frame_start_time

std::chrono::time_point<std::chrono::steady_clock> Slic3r::GUI::GLCanvas3D::m_last_frame_start_time { std::chrono::steady_clock::now() }

private

807{ std::chrono::steady_clock::now() };

Referenced by on_idle().

◆ m_last_h

unsigned int Slic3r::GUI::GLCanvas3D::m_last_h

private

Referenced by _resize().

◆ m_last_w

unsigned int Slic3r::GUI::GLCanvas3D::m_last_w

private

Referenced by _resize().

◆ m_layers_editing

LayersEditing Slic3r::GUI::GLCanvas3D::m_layers_editing

private

◆ m_main_toolbar

GLToolbar Slic3r::GUI::GLCanvas3D::m_main_toolbar

mutableprivate

Referenced by GLCanvas3D(), _check_and_update_toolbar_icon_scale(), _deactivate_arrange_menu(), _deactivate_layersediting_menu(), _deactivate_orient_menu(), _init_main_toolbar(), _max_bounding_box(), _overlay_signature(), _render_arrange_menu(), _render_assemble_view_toolbar(), _render_bed(), _render_fps_overlay(), _render_frame(), _render_main_toolbar(), _render_orient_menu(), _render_overlays(), _render_plate_switcher(), _render_scene(), _render_separator_toolbar_left(), _render_separator_toolbar_right(), _switch_toolbars_icon_filename(), enable_main_toolbar(), force_main_toolbar_left_action(), force_main_toolbar_right_action(), get_main_toolbar_height(), get_main_toolbar_item_id(), get_main_toolbar_offset(), get_main_toolbar_width(), highlight_toolbar_item(), init(), is_bed_visible(), on_change_color_mode(), on_idle(), on_mouse(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_variable_layer_height_dialog(), and update_shortcut_tooltips().

◆ m_model

Model* Slic3r::GUI::GLCanvas3D::m_model

private

◆ m_mouse

Mouse Slic3r::GUI::GLCanvas3D::m_mouse

private

Referenced by _is_scene_cacheable(), _picking_pass(), _picking_pass_imex_ghosts(), _render_frame(), _render_imex_ghost_tooltip(), _render_scene(), get_local_mouse_position(), get_move_volume_id(), is_mouse_dragging(), is_mouse_left_up_ignored(), mouse_up_cleanup(), on_key(), on_mouse(), and set_mouse_as_dragging().

◆ m_mouse_wheel

int Slic3r::GUI::GLCanvas3D::m_mouse_wheel { 0 }

private

810{ 0 };

◆ m_moving

bool Slic3r::GUI::GLCanvas3D::m_moving

private

Referenced by GLCanvas3D(), _render_3d_navigator(), is_dragging(), mouse_up_cleanup(), and on_mouse().

◆ m_moving_enabled

bool Slic3r::GUI::GLCanvas3D::m_moving_enabled

private

Referenced by GLCanvas3D(), enable_moving(), and on_mouse().

◆ m_multisample_allowed

bool Slic3r::GUI::GLCanvas3D::m_multisample_allowed

private

Referenced by GLCanvas3D(), _rectangular_selection_picking_pass(), allow_multisample(), and init().

◆ m_navigator_dragging

bool Slic3r::GUI::GLCanvas3D::m_navigator_dragging { false }

private

780{ false };

Referenced by _render_3d_navigator(), bind_event_handlers(), and on_mouse().

◆ m_old_size

std::array<unsigned int, 2> Slic3r::GUI::GLCanvas3D::m_old_size { 0, 0 }

private

741{ 0, 0 };

Referenced by _resize(), and reset_old_size().

◆ m_orient_settings_fff

OrientSettings Slic3r::GUI::GLCanvas3D::m_orient_settings_fff

private

◆ m_orient_settings_sla

OrientSettings Slic3r::GUI::GLCanvas3D::m_orient_settings_sla

private

◆ m_overlay_dirty

bool Slic3r::GUI::GLCanvas3D::m_overlay_dirty { false }

private

747{ false };

Referenced by _set_overlay_as_dirty(), and on_idle().

◆ m_paint_toolbar_width

float Slic3r::GUI::GLCanvas3D::m_paint_toolbar_width

mutableprivate

Referenced by _render_paint_toolbar(), and get_assembly_paint_toolbar_width().

◆ m_picking_enabled

bool Slic3r::GUI::GLCanvas3D::m_picking_enabled

private

Referenced by GLCanvas3D(), _is_xray_view_active(), _picking_pass(), _picking_pass_imex_ghosts(), _rectangular_selection_picking_pass(), _render_frame(), _render_objects(), _render_scene(), enable_picking(), on_key(), and on_mouse().

◆ m_plate_chrome_enabled

bool Slic3r::GUI::GLCanvas3D::m_plate_chrome_enabled {true}

private

676{true};

Referenced by _render_platelist(), and enable_plate_chrome().

◆ m_plate_shadow_mask

GLModel Slic3r::GUI::GLCanvas3D::m_plate_shadow_mask

Referenced by ~GLCanvas3D(), and _render_shadows().

◆ m_plate_shadow_mask_key

std::string Slic3r::GUI::GLCanvas3D::m_plate_shadow_mask_key

Referenced by ~GLCanvas3D(), and _render_shadows().

◆ m_plate_switcher_items

std::vector<std::unique_ptr<IMToolbarItem> > Slic3r::GUI::GLCanvas3D::m_plate_switcher_items

private

Referenced by ~GLCanvas3D(), and _render_plate_switcher().

◆ m_plate_switcher_scrollbar

bool Slic3r::GUI::GLCanvas3D::m_plate_switcher_scrollbar { false }

private

666{ false };

Referenced by _render_plate_switcher().

◆ m_plate_switcher_version

unsigned Slic3r::GUI::GLCanvas3D::m_plate_switcher_version { unsigned(-1) }

private

665{ unsigned(-1) };

Referenced by _render_plate_switcher().

◆ m_popup_menu_positon

std::optional<Vec2d> Slic3r::GUI::GLCanvas3D::m_popup_menu_positon

Referenced by clear_popup_menu_position(), get_popup_menu_position(), and set_popup_menu_position().

◆ m_presented_signature

std::optional<size_t> Slic3r::GUI::GLCanvas3D::m_presented_signature

Referenced by _render_frame(), on_paint(), and render().

◆ m_process

BackgroundSlicingProcess* Slic3r::GUI::GLCanvas3D::m_process

private

Referenced by GLCanvas3D(), _get_current_partplate_print_volume(), _render_imgui_select_plate_toolbar(), current_printer_technology(), fff_print(), set_process(), and sla_print().

◆ m_rectangle_selection

GLSelectionRectangle Slic3r::GUI::GLCanvas3D::m_rectangle_selection

private

Referenced by _is_scene_cacheable(), _rectangular_selection_picking_pass(), _render_3d_navigator(), _render_frame(), _render_scene(), _update_selection_from_hover(), on_key(), and on_mouse().

◆ m_reload_delayed

bool Slic3r::GUI::GLCanvas3D::m_reload_delayed

private

Referenced by GLCanvas3D(), _render_frame(), is_reload_delayed(), and reload_scene().

◆ m_render_preview

bool Slic3r::GUI::GLCanvas3D::m_render_preview { true }

private

750{ true };

Referenced by _render_frame(), _render_imgui_select_plate_toolbar(), _render_scene(), _scene_cache_key(), is_bed_visible(), and Slic3r::GUI::GLCanvas3D::CenterOfMass::render().

◆ m_render_sla_auxiliaries

bool Slic3r::GUI::GLCanvas3D::m_render_sla_auxiliaries

private

Referenced by GLCanvas3D(), _picking_pass(), _render_volumes_for_picking(), _render_xray_volumes(), toggle_selected_volume_visibility(), and toggle_sla_auxiliaries_visibility().

◆ m_render_stats

RenderStats Slic3r::GUI::GLCanvas3D::m_render_stats

private

Referenced by _render_fps_overlay(), and _render_frame().

◆ m_render_timer

RenderTimer Slic3r::GUI::GLCanvas3D::m_render_timer

private

Referenced by GLCanvas3D(), and schedule_extra_frame().

◆ m_requires_check_outside_state

bool Slic3r::GUI::GLCanvas3D::m_requires_check_outside_state { false }

private

739{ false };

Referenced by _render_objects(), and requires_check_outside_state().

◆ m_return_toolbar

IMReturnToolbar Slic3r::GUI::GLCanvas3D::m_return_toolbar

mutableprivate

Referenced by GLCanvas3D(), _init_return_toolbar(), _render_return_toolbar(), and enable_return_toolbar().

◆ m_rotation_center

Vec3d Slic3r::GUI::GLCanvas3D::m_rotation_center { 0.0, 0.0, 0.0}

mutableprivate

792{ 0.0, 0.0, 0.0};

Referenced by on_mouse().

◆ m_sc

float Slic3r::GUI::GLCanvas3D::m_sc {1}

mutableprivate

670{1};

◆ m_scene_cache

SceneCache Slic3r::GUI::GLCanvas3D::m_scene_cache

Referenced by ~GLCanvas3D(), _can_reuse_cached_scene(), _capture_scene_cache(), and _render_frame().

◆ m_scene_raycaster

SceneRaycaster Slic3r::GUI::GLCanvas3D::m_scene_raycaster

private

Referenced by _mouse_to_3d(), _picking_pass(), _render_scene(), add_raycaster_for_picking(), get_camera_pan_anchor(), get_raycasters_for_picking(), reload_scene(), remove_raycasters_for_picking(), remove_raycasters_for_picking(), and set_raycaster_gizmos_on_top().

◆ m_section_view

std::shared_ptr<SectionView> Slic3r::GUI::GLCanvas3D::m_section_view { std::make_shared<SectionView>(this) }

private

719{ std::make_shared<SectionView>(this) };

Referenced by ~GLCanvas3D(), _get_section_view_plane(), _render_canvas_toolbar(), _render_section_view_panel(), align_section_view_to_camera(), get_section_view_normal(), get_section_view_ratio(), is_section_view_active(), on_key(), set_section_view_ratio(), share_section_view(), and toggle_section_view().

◆ m_section_view_caps

std::map<const GLVolume*, MeshClipper> Slic3r::GUI::GLCanvas3D::m_section_view_caps

private

Referenced by ~GLCanvas3D(), _render_section_view_caps(), and reset_volumes().

◆ m_sel_plate_toolbar

IMToolbar Slic3r::GUI::GLCanvas3D::m_sel_plate_toolbar

mutableprivate

Referenced by ~GLCanvas3D(), _init_select_plate_toolbar(), _render_imgui_select_plate_toolbar(), _update_imgui_select_plate_toolbar(), _update_select_plate_toolbar_stats_item(), enable_select_plate_toolbar(), is_all_plates_selected(), and reset_select_plate_toolbar_selection().

◆ m_selected_extruder

int Slic3r::GUI::GLCanvas3D::m_selected_extruder

private

Referenced by set_selected_extruder().

◆ m_selection

Selection Slic3r::GUI::GLCanvas3D::m_selection

private

Referenced by GLCanvas3D(), _max_bounding_box(), _render_assemble_control(), _render_assemble_info(), _render_below_plate_volumes(), _render_canvas_toolbar(), _render_objects(), _render_selection(), _render_selection_sidebar_hints(), _update_selection_from_hover(), _update_volumes_hover_state(), apply_selection_move(), apply_selection_rotate(), delete_selected(), deselect_all(), do_center(), do_center_plate(), do_drop(), do_mirror(), do_move(), do_rotate(), do_scale(), enable_selection(), get_camera_orbit_target(), get_selection(), get_selection(), handle_shortcut(), init(), mirror_selection(), on_mouse(), on_mouse_wheel(), reload_scene(), remove_curr_plate_all(), reset_volumes(), select_all(), select_curr_plate_all(), select_object_from_idx(), set_model(), set_selected_visible(), toggle_selected_volume_visibility(), and zoom_to_selection().

◆ m_selection_edit

SelectionEdit Slic3r::GUI::GLCanvas3D::m_selection_edit

private

Referenced by apply_selection_move(), apply_selection_rotate(), bind_event_handlers(), finish_selection_edit(), handle_shortcut(), and on_key().

◆ m_separator_toolbar

GLToolbar Slic3r::GUI::GLCanvas3D::m_separator_toolbar

mutableprivate

Referenced by GLCanvas3D(), _check_and_update_toolbar_icon_scale(), _init_separator_toolbar(), _overlay_signature(), _render_assemble_view_toolbar(), _render_fps_overlay(), _render_separator_toolbar_left(), _render_separator_toolbar_right(), _switch_toolbars_icon_filename(), enable_separator_toolbar(), get_main_toolbar_offset(), get_separator_toolbar_height(), get_separator_toolbar_width(), and on_change_color_mode().

◆ m_sequential_print_clearance

SequentialPrintClearance Slic3r::GUI::GLCanvas3D::m_sequential_print_clearance

Referenced by _render_sequential_clearance(), reset_sequential_print_clearance(), set_sequential_print_clearance_polygons(), set_sequential_print_clearance_render_fill(), set_sequential_print_clearance_visible(), and update_sequential_clearance().

◆ m_sequential_print_clearance_first_displacement

bool Slic3r::GUI::GLCanvas3D::m_sequential_print_clearance_first_displacement { true }

878{ true };

Referenced by on_mouse(), and update_sequential_clearance().

◆ m_shadow_light_vp

Transform3d Slic3r::GUI::GLCanvas3D::m_shadow_light_vp { Transform3d::Identity() }

938{ Transform3d::Identity() };

Referenced by _render_gcode(), _render_objects(), and _render_shadows().

◆ m_shadow_map_fbo

unsigned int Slic3r::GUI::GLCanvas3D::m_shadow_map_fbo { 0 }

935{ 0 };

Referenced by ~GLCanvas3D(), and _render_shadows().

◆ m_shadow_map_key

size_t Slic3r::GUI::GLCanvas3D::m_shadow_map_key { 0 }

941{ 0 };

Referenced by _render_shadows().

◆ m_shadow_map_size

unsigned int Slic3r::GUI::GLCanvas3D::m_shadow_map_size { 0 }

937{ 0 };

Referenced by _bind_gcode_shadow_map(), _render_gcode(), _render_objects(), and _render_shadows().

◆ m_shadow_map_texture_id

unsigned int Slic3r::GUI::GLCanvas3D::m_shadow_map_texture_id { 0 }

936{ 0 };

Referenced by ~GLCanvas3D(), _bind_gcode_shadow_map(), _render_objects(), and _render_shadows().

◆ m_shadow_map_valid

bool Slic3r::GUI::GLCanvas3D::m_shadow_map_valid { false }

939{ false };

Referenced by _bind_gcode_shadow_map(), _render_objects(), _render_scene(), and _render_shadows().

◆ m_shadow_plate_bounds

std::array<float, 4> Slic3r::GUI::GLCanvas3D::m_shadow_plate_bounds { { 0.0f, 0.0f, 0.0f, 0.0f } }

943{ { 0.0f, 0.0f, 0.0f, 0.0f } };

Referenced by _render_shadows().

◆ m_shortcuts_assembly_view

std::vector<std::pair<wxString, wxString> > Slic3r::GUI::GLCanvas3D::m_shortcuts_assembly_view

private

Referenced by GLCanvas3D(), and _render_assembly_tooltip_button().

◆ m_show_bed

bool Slic3r::GUI::GLCanvas3D::m_show_bed {true}

private

684{true};

Referenced by _render_scene(), get_show_bed(), is_bed_visible(), and set_show_bed().

◆ m_show_world_axes

bool Slic3r::GUI::GLCanvas3D::m_show_world_axes {true}

private

826{true};

Referenced by _render_canvas_toolbar(), _render_scene(), init(), and toggle_world_axes_visibility().

◆ m_sidebar_field

std::string Slic3r::GUI::GLCanvas3D::m_sidebar_field

private

Referenced by GLCanvas3D(), _render_selection_sidebar_hints(), and handle_sidebar_focus_event().

◆ m_sinking_contours_enabled

bool Slic3r::GUI::GLCanvas3D::m_sinking_contours_enabled {true}

private

687{true};

Referenced by _render_objects(), and enable_sinking_contours().

◆ m_sla_caps

std::array<SlaCap, 2> Slic3r::GUI::GLCanvas3D::m_sla_caps

private

Referenced by _render_sla_slices(), reset_clipping_planes_cache(), and set_clipping_plane().

◆ m_slope

Slope Slic3r::GUI::GLCanvas3D::m_slope

private

Referenced by GLCanvas3D(), enable_slope(), init(), is_overhang_shown(), is_using_slope(), set_slope_normal_angle(), show_overhang(), and use_slope().

◆ m_ssao_color_texture_id

unsigned int Slic3r::GUI::GLCanvas3D::m_ssao_color_texture_id { 0 }

924{ 0 };

Referenced by ~GLCanvas3D(), and _render_ssao_pass().

◆ m_ssao_depth_texture_id

unsigned int Slic3r::GUI::GLCanvas3D::m_ssao_depth_texture_id { 0 }

925{ 0 };

Referenced by ~GLCanvas3D(), and _render_ssao_pass().

◆ m_ssao_texture_size

std::array<unsigned int, 2> Slic3r::GUI::GLCanvas3D::m_ssao_texture_size { { 0, 0 } }

926{ { 0, 0 } };

Referenced by _render_ssao_pass().

◆ m_studio_lighting

bool Slic3r::GUI::GLCanvas3D::m_studio_lighting {false}

private

706{false};

Referenced by _render_objects(), and set_studio_lighting().

◆ m_timer

wxTimer Slic3r::GUI::GLCanvas3D::m_timer

private

Referenced by GLCanvas3D(), _start_timer(), and _stop_timer().

◆ m_timer_set_color

wxTimer Slic3r::GUI::GLCanvas3D::m_timer_set_color

private

Referenced by GLCanvas3D(), on_char(), and on_set_color_timer().

◆ m_toolbar_highlighter

struct Slic3r::GUI::GLCanvas3D::ToolbarHighlighter Slic3r::GUI::GLCanvas3D::m_toolbar_highlighter

Referenced by _render_main_toolbar(), bind_event_handlers(), and highlight_toolbar_item().

◆ m_toolpath_outside

bool Slic3r::GUI::GLCanvas3D::m_toolpath_outside { false }

private

777{ false };

Referenced by _render_background().

◆ m_tooltip

Tooltip Slic3r::GUI::GLCanvas3D::m_tooltip

private

Referenced by _render_frame(), on_mouse(), and set_tooltip().

◆ m_tooltip_enabled

bool Slic3r::GUI::GLCanvas3D::m_tooltip_enabled { true }

private

816{ true };

Referenced by _render_frame(), on_mouse(), and on_set_focus().

◆ m_use_clipping_planes

bool Slic3r::GUI::GLCanvas3D::m_use_clipping_planes

private

Referenced by GLCanvas3D(), _render_objects(), _render_sla_slices(), get_use_clipping_planes(), and set_use_clipping_planes().

◆ m_volumes

GLVolumeCollection Slic3r::GUI::GLCanvas3D::m_volumes

private

Referenced by GLCanvas3D(), _is_any_volume_outside(), _load_sla_shells(), _picking_pass(), _rectangular_selection_picking_pass(), _render_assemble_control(), _render_background(), _render_below_plate_volumes(), _render_canvas_toolbar(), _render_imex_ghosts(), _render_imex_ghosts_xray(), _render_objects(), _render_section_view_caps(), _render_shadows(), _render_volumes_for_picking(), _render_wireframe_overlay(), _render_xray_volumes(), _scene_cache_key(), _set_warning_notification_if_needed(), _shadow_casters_signature(), _update_inactive_plates_visibility(), _update_selection_from_hover(), _update_volumes_hover_state(), check_volumes_outside_state(), do_mirror(), do_move(), do_rotate(), do_scale(), ensure_on_bed(), get_volumes(), get_volumes_count(), get_wipe_tower_info(), is_object_sinking(), load_object(), on_mouse(), on_mouse_wheel(), reload_scene(), render_thumbnail(), reset_volumes(), set_color_clip_plane(), set_color_clip_plane_colors(), set_use_color_clip_plane(), set_volumes_z_range(), toggle_model_objects_visibility(), toggle_selected_volume_visibility(), toggle_sla_auxiliaries_visibility(), update_compacted_wipe_tower_clearance(), update_instance_printable_state_for_object(), update_sequential_clearance(), update_volumes_colors_by_extruder(), and volumes_bounding_box().

◆ s_frames_in_progress

int Slic3r::GUI::GLCanvas3D::s_frames_in_progress = 0

staticprivate

Referenced by _render_frame(), is_frame_in_progress(), and Slic3r::GUI::wxDEFINE_EVENT().

◆ split_to_objects_count

int Slic3r::GUI::GLCanvas3D::split_to_objects_count = 0

private

◆ split_to_part_count

int Slic3r::GUI::GLCanvas3D::split_to_part_count = 0

private

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

/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/GLCanvas3D.hpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/GLCanvas3D.cpp

	OrcaSlicer latest OrcaSlicer

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Class Documentation

◆ Slic3r::GUI::GLCanvas3D::ArrangeSettings

◆ Slic3r::GUI::GLCanvas3D::OrientSettings

◆ Slic3r::GUI::GLCanvas3D::KeyDown

Member Enumeration Documentation

◆ ECameraNavigationType

◆ ECanvasType

◆ ECursorType

◆ EShadowMode

◆ EWarning

◆ MouseAction

◆ MouseButton

Constructor & Destructor Documentation

◆ GLCanvas3D()

◆ ~GLCanvas3D()

Member Function Documentation

◆ _bind_gcode_shadow_map()

◆ _can_reuse_cached_scene()

◆ _capture_scene_cache()

◆ _check_and_update_toolbar_icon_scale()

◆ _current_plate_box()

◆ _deactivate_arrange_menu()

◆ _deactivate_collapse_toolbar_items()

◆ _deactivate_layersediting_menu()

◆ _deactivate_orient_menu()

◆ _get_current_partplate_print_volume()

◆ _get_effective_fps_cap()

◆ _get_section_view_plane()

◆ _get_volumes_clipping_plane()

◆ _hides_inactive_plates()

◆ _init_assemble_view_toolbar()

◆ _init_collapse_toolbar()

◆ _init_main_toolbar()

◆ _init_return_toolbar()

◆ _init_select_plate_toolbar()

◆ _init_separator_toolbar()

◆ _init_toolbars()

◆ _is_any_volume_outside()

◆ _is_below_plate_view_active()

◆ _is_fps_overlay_enabled()

◆ _is_frame_skipping_enabled()

◆ _is_fxaa_enabled()

◆ _is_realistic_view_enabled()

◆ _is_render_timings_enabled()

◆ _is_scene_cache_enabled()

◆ _is_scene_cacheable()

◆ _is_shown_on_screen()

◆ _is_ssao_enabled()

◆ _is_xray_view_active()

◆ _load_sla_shells()

◆ _max_bounding_box()

◆ _mouse_to_3d()

◆ _mouse_to_bed_3d()

◆ _on_section_view_changed()

◆ _overlay_signature()

◆ _perform_layer_editing_action()

◆ _picking_pass()

◆ _picking_pass_imex_ghosts()

◆ _rectangular_selection_picking_pass()

◆ _refresh_if_shown_on_screen()

◆ _render_3d_navigator()

◆ _render_arrange_menu()

◆ _render_assemble_control()

◆ _render_assemble_info()

◆ _render_assemble_view_toolbar()

◆ _render_assembly_tooltip_button()

◆ _render_background()

◆ _render_bed()

◆ _render_below_plate_volumes()