Slic3r::GLVolumeCollection Class Reference

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

Collaboration diagram for Slic3r::GLVolumeCollection:

Classes
struct	PrintVolume
struct	Slope

Public Types
enum class	ERenderType : unsigned char { Opaque , Transparent , All }

Public Member Functions
	GLVolumeCollection ()
	~GLVolumeCollection ()
std::vector< int >	load_object (const ModelObject *model_object, int obj_idx, const std::vector< int > &instance_idxs, const std::string &color_by, bool opengl_initialized, bool need_raycaster=true)
int	load_object_volume (const ModelObject *model_object, int obj_idx, int volume_idx, int instance_idx, const std::string &color_by, bool opengl_initialized, bool in_assemble_view=false, bool use_loaded_id=false, bool need_raycaster=true)
void	load_object_auxiliary (const SLAPrintObject *print_object, int obj_idx, const std::vector< std::pair< size_t, size_t > > &instances, SLAPrintObjectStep milestone, size_t timestamp)
int	load_wipe_tower_preview (int obj_idx, float pos_x, float pos_y, float width, float depth, float height, float rotation_angle, bool size_unknown, float brim_width)
int	load_real_wipe_tower_preview (int obj_idx, float pos_x, float pos_y, const TriangleMesh &wt_mesh, const TriangleMesh &brim_mesh, bool render_brim, float rotation_angle, bool size_unknown, bool opengl_initialized)
GLVolume *	new_toolpath_volume (const ColorRGBA &rgba)
GLVolume *	new_nontoolpath_volume (const ColorRGBA &rgba)
float	get_selection_support_normal_z () const
void	render (ERenderType type, bool disable_cullface, const Transform3d &view_matrix, const Transform3d &projection_matrix, const GUI::Size &cnv_size, std::function< bool(const GLVolume &)> filter_func=std::function< bool(const GLVolume &)>(), bool partly_inside_enable=true, std::vector< double > *printable_heights=nullptr) const
void	clear ()
bool	empty () const
void	set_range (double low, double high)
void	set_print_volume (const PrintVolume &print_volume)
void	set_z_range (float min_z, float max_z)
void	set_clipping_plane (const std::array< double, 4 > &coeffs)
const std::array< float, 2 > &	get_z_range () const
const std::array< double, 4 > &	get_clipping_plane () 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_slope_GlobalActive () const
bool	is_slope_active () const
void	set_slope_active (bool active)
void	set_slope_GlobalActive (bool active)
float	get_slope_normal_z () const
void	set_slope_normal_z (float normal_z)
void	set_default_slope_normal_z ()
void	set_show_sinking_contours (bool show)
bool	check_outside_state (const Slic3r::BuildVolume &build_volume, ModelInstanceEPrintVolumeState *out_state, ObjectFilamentResults *object_results) const
void	reset_outside_state ()
bool	check_wipe_tower_outside_state (const Slic3r::BuildVolume &build_volume, int plate_id) const
void	update_colors_by_extruder (const DynamicPrintConfig *config, bool is_update_alpha=true)
std::vector< double >	get_current_print_zs (bool active_only) const
size_t	cpu_memory_used () const
size_t	gpu_memory_used () const
size_t	total_memory_used () const
std::string	log_memory_info () const
void	set_transparency (float alpha)

Public Attributes
GLVolumePtrs	volumes

Private Member Functions
	GLVolumeCollection (const GLVolumeCollection &other)
GLVolumeCollection &	operator= (const GLVolumeCollection &)

Private Attributes
PrintVolume	m_print_volume
PrintVolume	m_render_volume
std::array< float, 2 >	m_z_range
std::array< double, 4 >	m_clipping_plane
std::array< double, 4 >	m_color_clip_plane
bool	m_use_color_clip_plane { false }
std::array< ColorRGBA, 2 >	m_color_clip_plane_colors { ColorRGBA::RED(), ColorRGBA::BLUE() }
Slope	m_slope
bool	m_show_sinking_contours = false

Detailed Description

---

Class Documentation

Slic3r::GLVolumeCollection::PrintVolume

struct Slic3r::GLVolumeCollection::PrintVolume

Collaboration diagram for Slic3r::GLVolumeCollection::PrintVolume:

Class Members
array< float, 4 >	data
int	type { 0 }
array< float, 2 >	zs

Slic3r::GLVolumeCollection::Slope

struct Slic3r::GLVolumeCollection::Slope

Class Members
bool	active { false }
bool	isGlobalActive {false}
float	normal_z

Member Enumeration Documentation

ERenderType

enum class Slic3r::GLVolumeCollection::ERenderType : unsigned char

strong

Enumerator
Opaque
Transparent
All

    {
        Opaque,
        Transparent,
        All
    };

Constructor & Destructor Documentation

GLVolumeCollection() [1/2]

Slic3r::GLVolumeCollection::GLVolumeCollection ( )

inline

                         {
        set_default_slope_normal_z();
 
        //BBS init render volume
        m_render_volume.type = -1;
    }

References m_render_volume, and set_default_slope_normal_z().

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

Here is the call graph for this function:

Here is the caller graph for this function:

~GLVolumeCollection()

Slic3r::GLVolumeCollection::~GLVolumeCollection ( )

inline

{ clear(); }

References clear().

Here is the call graph for this function:

GLVolumeCollection() [2/2]

Slic3r::GLVolumeCollection::GLVolumeCollection ( const GLVolumeCollection & other )

private

References GLVolumeCollection().

Here is the call graph for this function:

Member Function Documentation

check_outside_state()

bool Slic3r::GLVolumeCollection::check_outside_state	(	const Slic3r::BuildVolume &	build_volume,
		ModelInstanceEPrintVolumeState *	out_state,
		ObjectFilamentResults *	object_results ) const

{
    if (GUI::wxGetApp().plater() == NULL)
    {
        if (out_state != nullptr)
            *out_state = ModelInstancePVS_Inside;
        return false;
    }
 
    const Model&        model              = GUI::wxGetApp().plater()->model();
    auto                volume_below       = [](GLVolume& volume) -> bool
        { return volume.object_idx() != -1 && volume.volume_idx() != -1 && volume.is_below_printbed(); };
    // Volume is partially below the print bed, thus a pre-calculated convex hull cannot be used.
    auto                volume_sinking     = [](GLVolume& volume) -> bool
        { return volume.object_idx() != -1 && volume.volume_idx() != -1 && volume.is_sinking(); };
    // Cached bounding box of a volume above the print bed.
    auto                volume_bbox        = [volume_sinking](GLVolume& volume) -> BoundingBoxf3
        { return volume_sinking(volume) ? volume.transformed_non_sinking_bounding_box() : volume.transformed_convex_hull_bounding_box(); };
    // Cached 3D convex hull of a volume above the print bed.
    auto                volume_convex_mesh = [volume_sinking, &model](GLVolume& volume) -> const TriangleMesh&
        { return volume_sinking(volume) ? model.objects[volume.object_idx()]->volumes[volume.volume_idx()]->mesh() : *volume.convex_hull(); };
 
    ModelInstanceEPrintVolumeState overall_state = ModelInstancePVS_Fully_Outside;
    bool contained_min_one = false;
 
    //BBS: add instance judge logic, besides to original volume judge logic
    //std::map<int64_t, ModelInstanceEPrintVolumeState> model_state;
 
    GUI::PartPlate* curr_plate = GUI::wxGetApp().plater()->get_partplate_list().get_selected_plate();
    const Pointfs& pp_bed_shape = curr_plate->get_shape();
    BuildVolume plate_build_volume(pp_bed_shape, build_volume.printable_height(), build_volume.extruder_areas(), build_volume.extruder_heights());
    const std::vector<BoundingBoxf3>& exclude_areas = curr_plate->get_exclude_areas();
 
    const DynamicPrintConfig *plater_config = GUI::wxGetApp().plater()->config();
    std::vector<std::vector<BedExcludeRegion>> exclusion_regions;
    // Legacy bed-exclude areas retain Orca's existing 2D presentation. The
    // per-extruder 3D state is needed only after collision volumes are enabled.
    if (has_bed_exclude_volumes(*plater_config)) {
        exclusion_regions = get_bed_excluded_regions_by_extruder(*plater_config);
        // The native BuildVolume path below already presents the shared legacy
        // area. Merge only opt-in collision volumes into nozzle-specific state.
        for (std::vector<BedExcludeRegion> &regions : exclusion_regions)
            regions.erase(std::remove_if(regions.begin(), regions.end(),
                [](const BedExcludeRegion &region) { return !region.is_collision_volume(); }), regions.end());
    }
    const Vec3d plate_origin = curr_plate->get_origin();
    const Point exclusion_offset(scale_(plate_origin.x()), scale_(plate_origin.y()));
    for (std::vector<BedExcludeRegion> &regions : exclusion_regions)
        for (BedExcludeRegion &region : regions)
            region.polygon.translate(exclusion_offset);
 
    std::map<ModelObject*, std::map<int, std::set<int>>> objects_unprintable_filaments;
    const DynamicPrintConfig &plate_project_config = GUI::wxGetApp().preset_bundle->project_config;
    const int build_volume_extruder_count = build_volume.get_extruder_area_count();
    const int extruder_count = std::max<int>(build_volume_extruder_count, int(exclusion_regions.size()));
    std::vector<std::set<int>> unprintable_filament_ids(extruder_count, std::set<int>());
    std::set<ModelObject*> partly_objects_set;
    std::map<std::pair<int, int>, std::vector<bool>> instance_inside_exclusion_regions;
    const ModelObjectPtrs &model_objects = model.objects;
    for (GLVolume* volume : this->volumes)
    {
        std::vector<bool> inside_extruders;
        if (! volume->is_modifier && (volume->shader_outside_printer_detection_enabled || (! volume->is_wipe_tower && volume->composite_id.volume_id >= 0))) {
            BuildVolume::ObjectState state;
            if (volume_below(*volume))
                state = BuildVolume::ObjectState::Below;
            else {
                switch (plate_build_volume.type()) {
                case BuildVolume_Type::Rectangle: {
                    //FIXME this test does not evaluate collision of a build volume bounding box with non-convex objects.
                    const BoundingBoxf3& bb = volume_bbox(*volume);
                    state = plate_build_volume.volume_state_bbox(bb);
                    if ((state == BuildVolume::ObjectState::Inside) && (build_volume_extruder_count > 1))
                    {
                        state = plate_build_volume.check_volume_bbox_state_with_extruder_areas(bb, inside_extruders);
                    }
                    break;
                }
                case BuildVolume_Type::Circle:
                case BuildVolume_Type::Convex:
                //FIXME doing test on convex hull until we learn to do test on non-convex polygons efficiently.
                case BuildVolume_Type::Custom:
                {
                    const indexed_triangle_set& convex_mesh_it = volume_convex_mesh(*volume).its;
                    const Transform3f trafo = volume->world_matrix().cast<float>();
                    state = plate_build_volume.object_state(convex_mesh_it, trafo, volume_sinking(*volume));
                    if ((state == BuildVolume::ObjectState::Inside) && (build_volume_extruder_count > 1))
                    {
                        state = plate_build_volume.check_object_state_with_extruder_areas(convex_mesh_it, trafo, inside_extruders);
                    }
                    break;
                }
                default:
                    // Ignore, don't produce any collision.
                    state = BuildVolume::ObjectState::Inside;
                    break;
                }
                assert(state != BuildVolume::ObjectState::Below);
 
                // Preserve Orca's native printable-area result separately.
                // Exclusion collisions have current-map semantics and must not
                // leak into the later "unprintable on every possible nozzle"
                // aggregation used by automatic printable-area assignment.
                const std::vector<bool> printable_area_inside_extruders = inside_extruders;
 
                // Newer Orca resolves live multi-nozzle placement through this
                // per-extruder state vector. Merge exclusion-volume collisions
                // into the same source of truth instead of relying only on the
                // legacy PartPlate::check_outside() path.
                if ((state == BuildVolume::ObjectState::Inside || state == BuildVolume::ObjectState::Limited) &&
                    volume->object_idx() >= 0 && volume->object_idx() < int(model_objects.size()) &&
                    volume->instance_idx() >= 0 &&
                    volume->instance_idx() < int(model_objects[volume->object_idx()]->instances.size())) {
                    inside_extruders.resize(extruder_count, true);
 
                    const std::pair<int, int> instance_key{ volume->object_idx(), volume->instance_idx() };
                    auto [cache_it, inserted] = instance_inside_exclusion_regions.emplace(
                        instance_key, std::vector<bool>(extruder_count, true));
                    if (inserted) {
                        const ModelInstance *instance = model_objects[volume->object_idx()]->instances[volume->instance_idx()];
                        for (size_t extruder_id = 0; extruder_id < exclusion_regions.size(); ++extruder_id) {
                            if (instance->intersects_bed_exclude_regions(exclusion_regions[extruder_id]))
                                cache_it->second[extruder_id] = false;
                        }
                    }
 
                    bool exclusion_limited = false;
                    for (size_t extruder_id = 0; extruder_id < cache_it->second.size(); ++extruder_id) {
                        if (!cache_it->second[extruder_id]) {
                            inside_extruders[extruder_id] = false;
                            exclusion_limited = true;
                        }
                    }
 
                    if (exclusion_limited && state == BuildVolume::ObjectState::Inside)
                        state = extruder_count > 1 ? BuildVolume::ObjectState::Limited : BuildVolume::ObjectState::Colliding;
 
                }
 
                if (state == BuildVolume::ObjectState::Limited) {
                    //unprintable_filament_ids.resize(inside_extruders.size());
                    ModelObject *model_object = model_objects[volume->object_idx()];
                    ModelVolume *model_volume = model_object->volumes[volume->volume_idx()];
                    for (size_t i = 0; i < printable_area_inside_extruders.size(); ++i) {
                        if (!printable_area_inside_extruders[i]) {
                            std::vector<int> filaments = model_volume->get_extruders();
                            unprintable_filament_ids[i].insert(filaments.begin(), filaments.end());
                            if (object_results) {
                                std::map<int, std::set<int>>& obj_extruder_filament_maps = objects_unprintable_filaments[model_object];
                                std::set<int>& obj_extruder_filaments = obj_extruder_filament_maps[i+1];
                                obj_extruder_filaments.insert(filaments.begin(), filaments.end());
                            }
                        }
                    }
                }
            }
 
            //int64_t comp_id = ((int64_t)volume->composite_id.object_id << 32) | ((int64_t)volume->composite_id.instance_id);
            volume->is_outside = (state != BuildVolume::ObjectState::Inside && state != BuildVolume::ObjectState::Limited);
            volume->partly_inside = (state == BuildVolume::ObjectState::Colliding);
            if (volume->printable) {
                if (state == BuildVolume::ObjectState::Colliding)
                {
                    overall_state = ModelInstancePVS_Partly_Outside;
                    partly_objects_set.emplace(model_objects[volume->object_idx()]);
                }
                else if ((state == BuildVolume::ObjectState::Limited) && (overall_state != ModelInstancePVS_Partly_Outside))
                    overall_state = ModelInstancePVS_Limited;
                else if ((state == BuildVolume::ObjectState::Inside) && (overall_state == ModelInstancePVS_Fully_Outside)) {
                    overall_state = ModelInstancePVS_Fully_Outside;
                }
                contained_min_one |= !volume->is_outside;
            }
 
            /*ModelInstanceEPrintVolumeState volume_state;
            //if (volume->is_outside && (plate_build_volume.bounding_volume().intersects(volume->bounding_box())))
            if (volume->is_outside && (state == BuildVolume::ObjectState::Colliding))
                volume_state = ModelInstancePVS_Partly_Outside;
            else if (volume->is_outside)
                volume_state = ModelInstancePVS_Fully_Outside;
            else
                volume_state = ModelInstancePVS_Inside;
 
            if (model_state.find(comp_id) != model_state.end())
            {
                if (model_state[comp_id] != ModelInstancePVS_Partly_Outside)
                {
                    if (volume_state == ModelInstancePVS_Partly_Outside)
                        model_state[comp_id] = ModelInstancePVS_Partly_Outside;
                    else if (model_state[comp_id] != volume_state)
                    {
                        model_state[comp_id] = ModelInstancePVS_Partly_Outside;
                    }
                }
            }
            else
            {
                model_state[comp_id] = volume_state;
            }
 
            if (model_state[comp_id] == ModelInstancePVS_Partly_Outside) {
                overall_state = ModelInstancePVS_Partly_Outside;
                BOOST_LOG_TRIVIAL(debug) << "instance includes " << volume->name << " is partially outside of bed";
            }*/
        }
    }
 
    std::vector<std::vector<int>> unprintable_filament_vec;
    for (const std::set<int>& filamnt_ids : unprintable_filament_ids) {
        unprintable_filament_vec.emplace_back(std::vector<int>(filamnt_ids.begin(), filamnt_ids.end()));
    }
 
    if (object_results && !partly_objects_set.empty()) {
        object_results->partly_outside_objects = std::vector<ModelObject*>(partly_objects_set.begin(), partly_objects_set.end());
    }
 
    //check per-object error for extruder areas
    if (object_results && (extruder_count > 1))
    {
        object_results->mode = curr_plate->get_real_filament_map_mode(plate_project_config);
        if (object_results->mode < FilamentMapMode::fmmManual)
        {
            std::vector<int> conflict_filament_vector;
            for (int index = 0; index < extruder_count; index++ )
            {
                if (!unprintable_filament_vec[index].empty())
                {
                    std::sort (unprintable_filament_vec[index].begin(), unprintable_filament_vec[index].end());
                    if (index == 0)
                        conflict_filament_vector = unprintable_filament_vec[index];
                    else
                    {
                        std::vector<int> result_filaments;
                        //result_filaments.reserve(conflict_filaments.size());
                        std::set_intersection (conflict_filament_vector.begin(), conflict_filament_vector.end(), unprintable_filament_vec[index].begin(), unprintable_filament_vec[index].end(), std::insert_iterator<std::vector<int>>(result_filaments, result_filaments.begin()));
                        conflict_filament_vector = result_filaments;
                    }
                }
                else
                {
                    conflict_filament_vector.clear();
                    break;
                }
            }
 
            if (!conflict_filament_vector.empty())
            {
                std::set<int> conflict_filaments_set(conflict_filament_vector.begin(), conflict_filament_vector.end());
                object_results->filaments = conflict_filament_vector;
 
                for (auto& object_map: objects_unprintable_filaments)
                {
                    ModelObject *model_object = object_map.first;
                    std::map<int, std::set<int>>& obj_extruder_filament_maps = object_map.second;
                    std::set<int> obj_filaments_set;
                    ObjectFilamentInfo object_filament_info;
                    object_filament_info.object = model_object;
 
                    for (std::map<int, std::set<int>>::iterator extruder_map_iter = obj_extruder_filament_maps.begin(); extruder_map_iter != obj_extruder_filament_maps.end(); extruder_map_iter++ )
                    {
                        int extruder_id = extruder_map_iter->first;
                        std::set<int>& filaments_set = extruder_map_iter->second;
 
                        for (int filament: filaments_set)
                        {
                            if (conflict_filaments_set.find(filament) != conflict_filaments_set.end())
                            {
                                obj_filaments_set.emplace(filament);
                            }
                        }
                    }
                    if (!obj_filaments_set.empty()) {
                        object_filament_info.auto_filaments = std::vector<int>(obj_filaments_set.begin(), obj_filaments_set.end());
                        object_results->object_filaments.push_back(std::move(object_filament_info));
                    }
                }
            }
        }
        else
        {
            std::set<int> conflict_filaments_set;
            std::vector<int> filament_maps = curr_plate->get_real_filament_maps(plate_project_config);
            for (auto& object_map: objects_unprintable_filaments)
            {
                ModelObject *model_object = object_map.first;
                std::map<int, std::set<int>>& obj_extruder_filament_maps = object_map.second;
                ObjectFilamentInfo object_filament_info;
                object_filament_info.object = model_object;
 
                for (std::map<int, std::set<int>>::iterator extruder_map_iter = obj_extruder_filament_maps.begin(); extruder_map_iter != obj_extruder_filament_maps.end(); extruder_map_iter++ )
                {
                    int extruder_id = extruder_map_iter->first;
                    std::set<int>& filaments_set = extruder_map_iter->second;
 
                    for (int filament: filaments_set)
                    {
                        if (filament > 0 && size_t(filament) <= filament_maps.size() &&
                            filament_maps[filament - 1] == extruder_id)
                        {
                            object_filament_info.manual_filaments.emplace(filament, extruder_id);
                            object_results->filament_maps[filament] = extruder_id;
                            conflict_filaments_set.emplace(filament);
                        }
                    }
                }
                if (!object_filament_info.manual_filaments.empty())
                {
                    object_results->object_filaments.push_back(std::move(object_filament_info));
                }
            }
            if (!conflict_filaments_set.empty()) {
                object_results->filaments = std::vector<int>(conflict_filaments_set.begin(), conflict_filaments_set.end());
            }
        }
 
    }
 
    /*for (GLVolume* volume : this->volumes)
    {
        if (! volume->is_modifier && (volume->shader_outside_printer_detection_enabled || (! volume->is_wipe_tower && volume->composite_id.volume_id >= 0)))
        {
            int64_t comp_id = ((int64_t)volume->composite_id.object_id << 32) | ((int64_t)volume->composite_id.instance_id);
            if (model_state.find(comp_id) != model_state.end())
            {
                if (model_state[comp_id] == ModelInstancePVS_Partly_Outside) {
                    volume->partly_inside = true;
                }
                else
                    volume->partly_inside = false;
            }
        }
    }*/
 
    if (out_state != nullptr)
        *out_state = overall_state;
 
    return contained_min_one;
}

References Slic3r::ObjectFilamentInfo::auto_filaments, Slic3r::BuildVolume::Below, Slic3r::BuildVolume::check_object_state_with_extruder_areas(), Slic3r::BuildVolume::check_volume_bbox_state_with_extruder_areas(), Slic3r::Circle, Slic3r::BuildVolume::Colliding, Slic3r::Convex, Slic3r::Custom, empty(), Slic3r::BuildVolume::extruder_areas(), Slic3r::BuildVolume::extruder_heights(), Slic3r::ObjectFilamentResults::filament_maps, Slic3r::ObjectFilamentResults::filaments, Slic3r::fmmManual, Slic3r::get_bed_excluded_regions_by_extruder(), Slic3r::GUI::PartPlate::get_exclude_areas(), Slic3r::BuildVolume::get_extruder_area_count(), Slic3r::ModelVolume::get_extruders(), Slic3r::GUI::PartPlate::get_origin(), Slic3r::GUI::PartPlate::get_real_filament_map_mode(), Slic3r::GUI::PartPlate::get_real_filament_maps(), Slic3r::GUI::PartPlate::get_shape(), Slic3r::has_bed_exclude_volumes(), Slic3r::BuildVolume::Inside, Slic3r::ModelInstance::intersects_bed_exclude_regions(), Slic3r::BuildVolume::Limited, Slic3r::ObjectFilamentInfo::manual_filaments, Slic3r::ObjectFilamentResults::mode, Slic3r::ModelInstancePVS_Fully_Outside, Slic3r::ModelInstancePVS_Inside, Slic3r::ModelInstancePVS_Limited, Slic3r::ModelInstancePVS_Partly_Outside, Slic3r::ObjectFilamentInfo::object, Slic3r::ObjectFilamentResults::object_filaments, Slic3r::BuildVolume::object_state(), Slic3r::Model::objects, Slic3r::ObjectFilamentResults::partly_outside_objects, Slic3r::BuildVolume::printable_height(), Slic3r::Rectangle, scale_, Slic3r::BuildVolume::type(), Slic3r::BuildVolume::volume_state_bbox(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

check_wipe_tower_outside_state()

bool Slic3r::GLVolumeCollection::check_wipe_tower_outside_state	(	const Slic3r::BuildVolume &	build_volume,
		int	plate_id ) const

{
    for (GLVolume *volume : this->volumes) {
        if (volume->is_wipe_tower) {
            int wipe_tower_plate_id = volume->composite_id.object_id - 1000;
            if (wipe_tower_plate_id != plate_id)
                continue;
            const std::vector<Vec2d>& printable_area = build_volume.printable_area();
            Polygon printable_poly = Polygon::new_scale(printable_area);
 
            // multi-extruder
            Polygons extruder_polys;
            const std::vector<std::vector<Vec2d>> & extruder_areas = build_volume.extruder_areas();
            if (!extruder_areas.empty()) {
                for (size_t i = 0; i < extruder_areas.size(); ++i) {
                    extruder_polys.emplace_back(Polygon::new_scale(extruder_areas[i]));
                }
                extruder_polys = union_(extruder_polys);
                if (extruder_polys.empty())
                    return false;
 
                printable_poly = extruder_polys[0];
            }
 
            const BoundingBoxf3 &bbox = volume->transformed_convex_hull_bounding_box();
            Polygon wipe_tower_polygon = bbox.polygon(true);
 
            Polygons diff_res = diff(wipe_tower_polygon, printable_poly);
            return diff_res.empty();
        }
    }
    return true;
}

References Slic3r::diff(), Slic3r::BuildVolume::extruder_areas(), Slic3r::Polygon::new_scale(), Slic3r::BoundingBox3Base< PointType >::polygon(), Slic3r::BuildVolume::printable_area(), Slic3r::printable_area(), and Slic3r::union_().

Here is the call graph for this function:

clear()

void Slic3r::GLVolumeCollection::clear ( )

inline

{ for (auto *v : volumes) delete v; volumes.clear(); }

References volumes.

Referenced by ~GLVolumeCollection().

Here is the caller graph for this function:

cpu_memory_used()

size_t Slic3r::GLVolumeCollection::cpu_memory_used

(

)

const

{
  size_t memsize = sizeof(*this) + this->volumes.capacity() * sizeof(GLVolume);
  for (const GLVolume *volume : this->volumes)
    memsize += volume->cpu_memory_used();
  return memsize;
}

Referenced by log_memory_info(), and total_memory_used().

Here is the caller graph for this function:

empty()

bool Slic3r::GLVolumeCollection::empty ( ) const

inline

{ return volumes.empty(); }

References volumes.

Referenced by check_outside_state().

Here is the caller graph for this function:

get_clipping_plane()

const std::array< double, 4 > & Slic3r::GLVolumeCollection::get_clipping_plane ( ) const

inline

{ return m_clipping_plane; }

References m_clipping_plane.

get_current_print_zs()

std::vector< double > Slic3r::GLVolumeCollection::get_current_print_zs

(

bool

active_only

)

const

{
    // Collect layer top positions of all volumes.
    std::vector<double> print_zs;
    for (GLVolume *vol : this->volumes)
    {
        if (!active_only || vol->is_active)
            append(print_zs, vol->print_zs);
    }
    std::sort(print_zs.begin(), print_zs.end());
 
    // Replace intervals of layers with similar top positions with their average value.
    int n = int(print_zs.size());
    int k = 0;
    for (int i = 0; i < n;) {
        int j = i + 1;
        coordf_t zmax = print_zs[i] + EPSILON;
        for (; j < n && print_zs[j] <= zmax; ++ j) ;
        print_zs[k ++] = (j > i + 1) ? (0.5 * (print_zs[i] + print_zs[j - 1])) : print_zs[i];
        i = j;
    }
    if (k < n)
        print_zs.erase(print_zs.begin() + k, print_zs.end());
 
    return print_zs;
}

References Slic3r::append(), and EPSILON.

Here is the call graph for this function:

get_selection_support_normal_z()

float Slic3r::GLVolumeCollection::get_selection_support_normal_z

(

)

const

{
    const DynamicPrintConfig& glb_cfg  = GUI::wxGetApp().preset_bundle->prints.get_edited_preset().config;
    const auto& full_cfg               = GUI::wxGetApp().preset_bundle->full_config();
    const auto support_type            = glb_cfg.opt_enum<SupportType>("support_type");
    const int  support_threshold_angle = glb_cfg.opt_int("support_threshold_angle");
    double angle_rad;
 
    if (support_threshold_angle > 0) {
        // Match support generation: explicit threshold angles are treated as inclusive.
        const int effective_support_threshold_angle = std::min(support_threshold_angle + 1, 89);
        angle_rad = Geometry::deg2rad(static_cast<double>(effective_support_threshold_angle));
    } else if (is_tree(support_type)) {
        angle_rad = Geometry::deg2rad(30.0); // fallback value for tree supports
    } else { // For normal supports, if the angle is set to 0, calculate normal_z from overlap.
        const double layer_height        = full_cfg.opt_float("layer_height");
        const auto*  nozzle_diameter_opt = full_cfg.option<ConfigOptionFloats>("nozzle_diameter");
        const int    wall_filament_id       = full_cfg.opt_int("outer_wall_filament_id");
        const size_t nozzle_count        = nozzle_diameter_opt->values.size();
        const size_t wall_extruder_idx   = (wall_filament_id > 0 && wall_filament_id <= static_cast<int>(nozzle_count))
            ? static_cast<size_t>(wall_filament_id - 1)
            : 0; // Invalid extruder index falls back to extruder 1.
        
        // Use wall extruder's nozzle diameter for better estimation of external perimeter width,
        // which is more relevant to overhang printing than the default nozzle diameter.
        const double nozzle_diameter = nozzle_diameter_opt->values[wall_extruder_idx];
 
        double external_perimeter_width = full_cfg.get_abs_value("outer_wall_line_width", nozzle_diameter);
        if (external_perimeter_width <= 0.0) {
            external_perimeter_width = full_cfg.get_abs_value("line_width", nozzle_diameter);
 
            if (external_perimeter_width <= 0.0)
                external_perimeter_width = nozzle_diameter;
        }
 
        const double overlap_width      = full_cfg.get_abs_value("support_threshold_overlap", external_perimeter_width);
        const double lower_layer_offset = std::max(0.0, external_perimeter_width - overlap_width);
 
        angle_rad = lower_layer_offset <= EPSILON ? Geometry::deg2rad(89.0) : std::atan(layer_height / lower_layer_offset);
    }
 
    return static_cast<float>(-std::cos(std::clamp(angle_rad, 0.0, Geometry::deg2rad(89.0))));
}

References Slic3r::Geometry::deg2rad(), EPSILON, Slic3r::is_tree(), Slic3r::layer_height(), Slic3r::nozzle_diameter(), Slic3r::DynamicConfig::opt_enum(), and Slic3r::DynamicConfig::opt_int().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

get_slope_normal_z()

float Slic3r::GLVolumeCollection::get_slope_normal_z ( ) const

inline

{ return m_slope.normal_z; }

References m_slope.

get_z_range()

const std::array< float, 2 > & Slic3r::GLVolumeCollection::get_z_range ( ) const

inline

{ return m_z_range; }

References m_z_range.

gpu_memory_used()

size_t Slic3r::GLVolumeCollection::gpu_memory_used

(

)

const

{
  size_t memsize = 0;
  for (const GLVolume *volume : this->volumes)
    memsize += volume->gpu_memory_used();
  return memsize;
}

Referenced by log_memory_info(), and total_memory_used().

Here is the caller graph for this function:

is_slope_active()

bool Slic3r::GLVolumeCollection::is_slope_active ( ) const

inline

{ return m_slope.active; }

References m_slope.

is_slope_GlobalActive()

bool Slic3r::GLVolumeCollection::is_slope_GlobalActive ( ) const

inline

{ return m_slope.isGlobalActive; }

References m_slope.

load_object()

std::vector< int > Slic3r::GLVolumeCollection::load_object	(	const ModelObject *	model_object,
		int	obj_idx,
		const std::vector< int > &	instance_idxs,
		const std::string &	color_by,
		bool	opengl_initialized,
		bool	need_raycaster = true )

{
    std::vector<int> volumes_idx;
    for (int volume_idx = 0; volume_idx < int(model_object->volumes.size()); ++volume_idx)
        for (int instance_idx : instance_idxs)
            volumes_idx.emplace_back(this->GLVolumeCollection::load_object_volume(model_object, obj_idx, volume_idx, instance_idx, color_by, opengl_initialized, false, false, need_raycaster));
    return volumes_idx;
}

References load_object_volume(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

load_object_auxiliary()

void Slic3r::GLVolumeCollection::load_object_auxiliary	(	const SLAPrintObject *	print_object,
		int	obj_idx,
		const std::vector< std::pair< size_t, size_t > > &	instances,
		SLAPrintObjectStep	milestone,
		size_t	timestamp )

{
    assert(print_object->is_step_done(milestone));
    Transform3d  mesh_trafo_inv = print_object->trafo().inverse();
    // Get the support mesh.
    TriangleMesh mesh = print_object->get_mesh(milestone);
    mesh.transform(mesh_trafo_inv);
    // Convex hull is required for out of print bed detection.
    TriangleMesh convex_hull = mesh.convex_hull_3d();
    for (const std::pair<size_t, size_t>& instance_idx : instances) {
        const ModelInstance& model_instance = *print_object->model_object()->instances[instance_idx.first];
        this->volumes.emplace_back(new GLVolume((milestone == slaposPad) ? GLVolume::SLA_PAD_COLOR : GLVolume::SLA_SUPPORT_COLOR));
        GLVolume& v = *this->volumes.back();
        v.model.init_from(mesh);
        v.model.set_color((milestone == slaposPad) ? GLVolume::SLA_PAD_COLOR : GLVolume::SLA_SUPPORT_COLOR);
        v.mesh_raycaster = std::make_unique<GUI::MeshRaycaster>(std::make_shared<const TriangleMesh>(mesh));
        v.composite_id = GLVolume::CompositeID(obj_idx, -int(milestone), (int)instance_idx.first);
        v.geometry_id = std::pair<size_t, size_t>(timestamp, model_instance.id().id);
        // Create a copy of the convex hull mesh for each instance. Use a move operator on the last instance.
        if (&instance_idx == &instances.back())
            v.set_convex_hull(std::move(convex_hull));
        else
            v.set_convex_hull(convex_hull);
        v.is_modifier = false;
        v.shader_outside_printer_detection_enabled = (milestone == slaposSupportTree);
        v.set_instance_transformation(model_instance.get_transformation());
        // Leave the volume transformation at identity.
        // v.set_volume_transformation(model_volume->get_transformation());
    }
}

References Slic3r::GLVolume::composite_id, Slic3r::Geometry::convex_hull(), Slic3r::TriangleMesh::convex_hull_3d(), Slic3r::GLVolume::geometry_id, Slic3r::SLAPrintObject::get_mesh(), Slic3r::ModelInstance::get_transformation(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::GUI::GLModel::init_from(), Slic3r::ModelObject::instances, Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnum, COUNT >::is_step_done(), Slic3r::GLVolume::mesh_raycaster, Slic3r::GLVolume::model, Slic3r::PrintObjectBase::model_object(), Slic3r::GUI::GLModel::set_color(), Slic3r::GLVolume::set_convex_hull(), Slic3r::GLVolume::set_instance_transformation(), Slic3r::GLVolume::SLA_PAD_COLOR, Slic3r::GLVolume::SLA_SUPPORT_COLOR, Slic3r::slaposPad, Slic3r::slaposSupportTree, Slic3r::SLAPrintObject::trafo(), Slic3r::TriangleMesh::transform(), and volumes.

Here is the call graph for this function:

load_object_volume()

int Slic3r::GLVolumeCollection::load_object_volume	(	const ModelObject *	model_object,
		int	obj_idx,
		int	volume_idx,
		int	instance_idx,
		const std::string &	color_by,
		bool	opengl_initialized,
		bool	in_assemble_view = false,
		bool	use_loaded_id = false,
		bool	need_raycaster = true )

{
    const ModelVolume   *model_volume = model_object->volumes[volume_idx];
    const int            extruder_id  = model_volume->extruder_id();
    const ModelInstance *instance     = model_object->instances[instance_idx];
    auto color = GLVolume::MODEL_COLOR[((color_by == "volume") ? volume_idx : obj_idx) % 4];
    color.a(model_volume->is_model_part() ? 0.7f : 0.4f);
 
    std::shared_ptr<const TriangleMesh> mesh = model_volume->mesh_ptr();
    this->volumes.emplace_back(new GLVolume(color));
    GLVolume& v = *this->volumes.back();
    v.set_color(color_from_model_volume(*model_volume));
    v.name = model_volume->name;
 
    v.model.init_from(*mesh);
    if (need_raycaster) { v.mesh_raycaster = std::make_unique<GUI::MeshRaycaster>(mesh); }
    v.composite_id = GLVolume::CompositeID(obj_idx, volume_idx, instance_idx);
 
    if (model_volume->is_model_part())
    {
        // GLVolume will reference a convex hull from model_volume!
        v.set_convex_hull(model_volume->get_convex_hull_shared_ptr());
        if (extruder_id != -1)
            v.extruder_id = extruder_id;
    }
    v.is_modifier = !model_volume->is_model_part();
    v.shader_outside_printer_detection_enabled = model_volume->is_model_part();
    if (in_assemble_view) {
        v.set_instance_transformation(instance->get_assemble_transformation());
        v.set_offset_to_assembly(instance->get_offset_to_assembly());
    }
    else
        v.set_instance_transformation(instance->get_transformation());
    v.set_volume_transformation(model_volume->get_transformation());
    //use object's instance id
    if (use_loaded_id && (instance->loaded_id > 0))
        v.model_object_ID = instance->loaded_id;
    else
        v.model_object_ID = instance->id().id;
 
    return int(this->volumes.size() - 1);
}

References Slic3r::color_from_model_volume(), Slic3r::GLVolume::composite_id, Slic3r::GLVolume::extruder_id, Slic3r::ModelVolume::extruder_id(), Slic3r::ModelInstance::get_assemble_transformation(), Slic3r::ModelVolume::get_convex_hull_shared_ptr(), Slic3r::ModelInstance::get_offset_to_assembly(), Slic3r::ModelInstance::get_transformation(), Slic3r::ModelVolume::get_transformation(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::GUI::GLModel::init_from(), Slic3r::ModelObject::instances, Slic3r::ModelVolume::is_model_part(), Slic3r::ModelInstance::loaded_id, Slic3r::ModelVolume::mesh_ptr(), Slic3r::GLVolume::mesh_raycaster, Slic3r::GLVolume::model, Slic3r::GLVolume::MODEL_COLOR, Slic3r::GLVolume::model_object_ID, Slic3r::GLVolume::name, Slic3r::ModelVolume::name, Slic3r::GLVolume::set_color(), Slic3r::GLVolume::set_convex_hull(), Slic3r::GLVolume::set_instance_transformation(), Slic3r::GLVolume::set_offset_to_assembly(), Slic3r::GLVolume::set_volume_transformation(), volumes, and Slic3r::ModelObject::volumes.

Referenced by load_object(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::CLI::run(), and Slic3r::GUI::Plater::update_obj_preview_thumbnail().

Here is the call graph for this function:

Here is the caller graph for this function:

load_real_wipe_tower_preview()

int Slic3r::GLVolumeCollection::load_real_wipe_tower_preview	(	int	obj_idx,
		float	pos_x,
		float	pos_y,
		const TriangleMesh &	wt_mesh,
		const TriangleMesh &	brim_mesh,
		bool	render_brim,
		float	rotation_angle,
		bool	size_unknown,
		bool	opengl_initialized )

{
    int plate_idx = obj_idx - 1000;
    if (wt_mesh.its.vertices.empty()) return int(this->volumes.size() - 1);
 
    std::vector<Slic3r::ColorRGBA> extruder_colors = GUI::wxGetApp().plater()->get_extruders_colors();
    GUI::PartPlateList               &ppl              = GUI::wxGetApp().plater()->get_partplate_list();
    std::vector<int>                  plate_extruders  = ppl.get_plate(plate_idx)->get_extruders(true);
    std::vector<Slic3r::ColorRGBA>    colors;
    if (!plate_extruders.empty()) {
        if (plate_extruders.front() <= extruder_colors.size())
            colors.push_back(extruder_colors[plate_extruders.front() - 1]);
        else
            colors.push_back(extruder_colors[0]);
    }
    if (colors.empty()) return int(this->volumes.size() - 1);
    volumes.emplace_back(new GLWipeTowerVolume({colors}));
    GLWipeTowerVolume &v = *dynamic_cast<GLWipeTowerVolume *>(volumes.back());
    auto mesh = wt_mesh;
    if (render_brim) {
        mesh.merge(brim_mesh);
    }
    if (!colors.empty()) {
        v.model_per_colors.resize(1);
        v.model_per_colors[0].init_from(mesh);
    }
    TriangleMesh wipe_tower_shell = mesh.convex_hull_3d();
    v.model.init_from(wipe_tower_shell);
    v.mesh_raycaster = std::make_unique<GUI::MeshRaycaster>(std::make_shared<const TriangleMesh>(wipe_tower_shell));
    v.set_convex_hull(wipe_tower_shell);
    v.set_volume_offset(Vec3d(pos_x, pos_y, 0.0));
    v.set_volume_rotation(Vec3d(0., 0., (M_PI / 180.) * rotation_angle));
    v.composite_id                             = GLVolume::CompositeID(obj_idx, 0, 0);
    v.geometry_id.first                        = 0;
    v.geometry_id.second                       = wipe_tower_instance_id().id + (obj_idx - 1000);
    v.is_wipe_tower                            = true;
    v.shader_outside_printer_detection_enabled = !size_unknown;
    return int(volumes.size() - 1);
}

References Slic3r::GLVolume::composite_id, Slic3r::TriangleMesh::convex_hull_3d(), Slic3r::GLVolume::geometry_id, Slic3r::GUI::PartPlate::get_extruders(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::ObjectID::id, Slic3r::GUI::GLModel::init_from(), Slic3r::TriangleMesh::its, M_PI, Slic3r::GLVolume::mesh_raycaster, Slic3r::GLVolume::model, Slic3r::GLWipeTowerVolume::model_per_colors, Slic3r::GLVolume::set_convex_hull(), Slic3r::GLVolume::set_volume_offset(), Slic3r::GLVolume::set_volume_rotation(), volumes, and Slic3r::wipe_tower_instance_id().

Here is the call graph for this function:

load_wipe_tower_preview()

int Slic3r::GLVolumeCollection::load_wipe_tower_preview	(	int	obj_idx,
		float	pos_x,
		float	pos_y,
		float	width,
		float	depth,
		float	height,
		float	rotation_angle,
		bool	size_unknown,
		float	brim_width )

{
    int plate_idx = obj_idx - 1000;
 
    if (depth < 0.01f)
        return int(this->volumes.size() - 1);
    if (height == 0.0f)
        height = 0.1f;
 
    std::vector<ColorRGBA> extruder_colors = GUI::wxGetApp().plater()->get_extruders_colors();
    std::vector<ColorRGBA> colors;
    GUI::PartPlateList& ppl = GUI::wxGetApp().plater()->get_partplate_list();
    std::vector<int> plate_extruders = ppl.get_plate(plate_idx)->get_extruders(true);
    TriangleMesh wipe_tower_shell = make_cube(width, depth, height);
    // The brim is part of the printed footprint: draw it and fold it into the shell so the
    // outside-bed shader and the drag clamp react to the true first-layer extent.
    const bool   show_brim   = brim_width > 0.f;
    const float  brim_height = 0.2f; // one first layer, visual only
    TriangleMesh brim_slab;
    if (show_brim) {
        // The brim follows the real first-layer outline: a Type2 cone-wall tower's base bulges
        // past the body box. The wall type and angle are print settings, the planner a printer one.
        const DynamicPrintConfig &print_cfg   = GUI::wxGetApp().preset_bundle->prints.get_edited_preset().config;
        const DynamicPrintConfig &printer_cfg = GUI::wxGetApp().preset_bundle->printers.get_edited_preset().config;
        const Polygon  outline      = estimate_wipe_tower_first_layer_outline(print_cfg, resolve_wipe_tower_type(printer_cfg), width, depth, height);
        const Polygons brim_outline = offset(outline, scaled(brim_width));
        brim_slab                   = WipeTower::its_make_rib_brim(brim_outline.empty() ? outline : brim_outline.front(), brim_height);
        wipe_tower_shell.merge(brim_slab);
    }
    for (int extruder_id : plate_extruders) {
        if (extruder_id <= extruder_colors.size())
            colors.push_back(extruder_colors[extruder_id - 1]);
        else
            colors.push_back(extruder_colors[0]);
    }
 
    // Orca: make it transparent
    for(auto& color : colors)
        color.a(0.66f);
    const size_t slab_count = colors.size(); // per-filament body slabs; the brim part comes after
    if (show_brim && !colors.empty())
        colors.push_back(colors.front());
    volumes.emplace_back(new GLWipeTowerVolume(colors));
    GLWipeTowerVolume& v = *dynamic_cast<GLWipeTowerVolume*>(volumes.back());
    v.model_per_colors.resize(colors.size());
    for (size_t i = 0; i < slab_count; i++) {
        TriangleMesh color_part = make_cube(width, depth / slab_count, height);
        color_part.translate({ 0.f, depth * i / slab_count, 0. });
        v.model_per_colors[i].init_from(color_part);
    }
    if (show_brim && !colors.empty())
        v.model_per_colors[slab_count].init_from(brim_slab);
    v.model.init_from(wipe_tower_shell);
    v.mesh_raycaster = std::make_unique<GUI::MeshRaycaster>(std::make_shared<const TriangleMesh>(wipe_tower_shell));
    v.set_convex_hull(wipe_tower_shell);
    v.set_volume_offset(Vec3d(pos_x, pos_y, 0.0));
    v.set_volume_rotation(Vec3d(0., 0., (M_PI / 180.) * rotation_angle));
    v.composite_id = GLVolume::CompositeID(obj_idx, 0, 0);
    v.geometry_id.first = 0;
    v.geometry_id.second = wipe_tower_instance_id().id + (obj_idx - 1000);
    v.is_wipe_tower = true;
    v.shader_outside_printer_detection_enabled = !size_unknown;
    return int(volumes.size() - 1);
}

References Slic3r::GLVolume::composite_id, Slic3r::estimate_wipe_tower_first_layer_outline(), Slic3r::GLVolume::geometry_id, Slic3r::GUI::PartPlate::get_extruders(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::ObjectID::id, Slic3r::GUI::GLModel::init_from(), Slic3r::WipeTower::its_make_rib_brim(), M_PI, Slic3r::make_cube(), Slic3r::TriangleMesh::merge(), Slic3r::GLVolume::mesh_raycaster, Slic3r::GLVolume::model, Slic3r::GLWipeTowerVolume::model_per_colors, Slic3r::offset(), Slic3r::resolve_wipe_tower_type(), Slic3r::scaled(), Slic3r::GLVolume::set_convex_hull(), Slic3r::GLVolume::set_volume_offset(), Slic3r::GLVolume::set_volume_rotation(), Slic3r::TriangleMesh::translate(), volumes, and Slic3r::wipe_tower_instance_id().

Here is the call graph for this function:

log_memory_info()

std::string Slic3r::GLVolumeCollection::log_memory_info

(

)

const

{
  return " (GLVolumeCollection RAM: " + format_memsize_MB(this->cpu_memory_used()) + " GPU: " + format_memsize_MB(this->gpu_memory_used()) + " Both: " + format_memsize_MB(this->gpu_memory_used()) + ")";
}

References cpu_memory_used(), Slic3r::format_memsize_MB(), and gpu_memory_used().

Here is the call graph for this function:

new_nontoolpath_volume()

GLVolume * Slic3r::GLVolumeCollection::new_nontoolpath_volume

(

const ColorRGBA &

rgba

)

{
    GLVolume* out = new GLVolume(rgba);
    out->is_extrusion_path = false;
    this->volumes.emplace_back(out);
    return out;
}

References volumes.

Referenced by new_toolpath_volume().

Here is the caller graph for this function:

new_toolpath_volume()

GLVolume * Slic3r::GLVolumeCollection::new_toolpath_volume

(

const ColorRGBA &

rgba

)

{
    GLVolume* out = new_nontoolpath_volume(rgba);
    out->is_extrusion_path = true;
    return out;
}

References new_nontoolpath_volume().

Here is the call graph for this function:

operator=()

GLVolumeCollection & Slic3r::GLVolumeCollection::operator= ( const GLVolumeCollection & )

private

References GLVolumeCollection().

Here is the call graph for this function:

render()

void Slic3r::GLVolumeCollection::render	(	GLVolumeCollection::ERenderType	type,
		bool	disable_cullface,
		const Transform3d &	view_matrix,
		const Transform3d &	projection_matrix,
		const GUI::Size &	cnv_size,
		std::function< bool(const GLVolume &)>	filter_func = std::function<bool(const GLVolume &)>(),
		bool	partly_inside_enable = true,
		std::vector< double > *	printable_heights = nullptr ) const

{
    GLVolumeWithIdAndZList to_render = volumes_to_render(volumes, type, view_matrix, filter_func);
    if (to_render.empty())
        return;
 
    GLShaderProgram* shader = GUI::wxGetApp().get_current_shader();
    if (shader == nullptr)
        return;
 
    GLShaderProgram* sink_shader = GUI::wxGetApp().get_shader("flat");
#if SLIC3R_OPENGL_ES
    GLShaderProgram* edges_shader = GUI::wxGetApp().get_shader("dashed_lines");
#else
    GLShaderProgram* edges_shader = GUI::OpenGLManager::get_gl_info().is_core_profile() ? GUI::wxGetApp().get_shader("dashed_thick_lines") : GUI::wxGetApp().get_shader("flat");
#endif // SLIC3R_OPENGL_ES
 
    if (type == ERenderType::Transparent) {
        glsafe(::glEnable(GL_BLEND));
        glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
    }
 
    glsafe(::glCullFace(GL_BACK));
    if (disable_cullface)
        glsafe(::glDisable(GL_CULL_FACE));
 
    const float support_normal_z = get_selection_support_normal_z();
 
    // The outline passes below are driven by is_outline, which only the object shaders have; with an
    // overlay one (wireframe, x-ray) bound they would just draw the volume again.
    const bool shader_can_outline = shader->get_uniform_location("is_outline") >= 0;
    // ORCA: the object shaders that know how draw a part of a translucent filament as its print would
    // show, in premultiplied color, see translucent_filament_color() in gouraud.fs
    const bool shade_translucent_filaments = type == ERenderType::Transparent && shader->get_uniform_location("translucent_filament") >= 0;
 
    // Prime depth_tex on every frame so non-outline draws do not keep the
    // default sampler unit 0, which can conflict with other sampler types.
    shader->set_uniform("depth_tex", OUTLINE_DEPTH_TEX_UNIT);
 
    // Compute up direction accounting for build plate tilt. This is frame-invariant
    // (config cannot change mid-render), so compute it once before the volume loop.
    const Vec3f up_direction = GUI::build_plate_tilt_up_direction().cast<float>();
 
    for (GLVolumeWithIdAndZ& volume : to_render) {
#if ENABLE_MODIFIERS_ALWAYS_TRANSPARENT
        if (type == ERenderType::Transparent) {
            volume.first->force_transparent = true;
            //BOOST_LOG_TRIVIAL(info) << boost::format("transparent rendering...");
        }
        //else
        //    BOOST_LOG_TRIVIAL(info) << boost::format("opaque rendering...");
#endif // ENABLE_MODIFIERS_ALWAYS_TRANSPARENT
        volume.first->set_render_color();
#if ENABLE_MODIFIERS_ALWAYS_TRANSPARENT
        if (type == ERenderType::Transparent)
            volume.first->force_transparent = false;
#endif // ENABLE_MODIFIERS_ALWAYS_TRANSPARENT
 
        // render sinking contours of non-hovered volumes
        shader->stop_using();
        if (sink_shader != nullptr) {
            sink_shader->start_using();
            if (m_show_sinking_contours) {
                if (volume.first->is_sinking() && !volume.first->is_below_printbed() &&
                    volume.first->hover == GLVolume::HS_None && !volume.first->force_sinking_contours) {
                    volume.first->render_sinking_contours();
                }
            }
            sink_shader->stop_using();
        }
        shader->start_using();
 
        if (!volume.first->model.is_initialized())
            shader->set_uniform("uniform_color", volume.first->render_color);
        shader->set_uniform("z_range", m_z_range);
        shader->set_uniform("clipping_plane", m_clipping_plane);
        shader->set_uniform("use_color_clip_plane", m_use_color_clip_plane);
        shader->set_uniform("color_clip_plane", m_color_clip_plane);
        shader->set_uniform("uniform_color_clip_plane_1", m_color_clip_plane_colors[0]);
        shader->set_uniform("uniform_color_clip_plane_2", m_color_clip_plane_colors[1]);
        //BOOST_LOG_TRIVIAL(info) << boost::format("set uniform_color to {%1%, %2%, %3%, %4%}, with_outline=%5%, selected %6%")
        //    %volume.first->render_color[0]%volume.first->render_color[1]%volume.first->render_color[2]%volume.first->render_color[3]
        //    %with_outline%volume.first->selected;
 
        //BBS set print_volume to render volume
        //shader->set_uniform("print_volume.type", static_cast<int>(m_render_volume.type));
        //shader->set_uniform("print_volume.xy_data", m_render_volume.data);
        //shader->set_uniform("print_volume.z_data", m_render_volume.zs);
 
        if (volume.first->partly_inside && partly_inside_enable) {
            //only partly inside volume need to be painted with boundary check
            shader->set_uniform("print_volume.type", static_cast<int>(m_print_volume.type));
            shader->set_uniform("print_volume.xy_data", m_print_volume.data);
            shader->set_uniform("print_volume.z_data", m_print_volume.zs);
        }
        else {
            //use -1 ad a invalid type
            shader->set_uniform("print_volume.type", -1);
        }
 
        // Per-extruder printable-height shading. The flag is set to
        // 2.0 only for multi-extruder printers (two per-extruder heights); otherwise it is forced to 0.0
        // on every render so no stale flag survives a multi->single-extruder plate switch, keeping the
        // shared gouraud shader pixel-identical for single-extruder printers. When active the height
        // branch reads print_volume.xy_data (the bed rect), so set it explicitly here.
        std::array<float, 3> extruder_printable_heights = {0.0f, 0.0f, 0.0f};
        if (printable_heights != nullptr && printable_heights->size() > 1) {
            extruder_printable_heights[0] = 2.0f;
            extruder_printable_heights[1] = static_cast<float>((*printable_heights)[0]);
            extruder_printable_heights[2] = static_cast<float>((*printable_heights)[1]);
            shader->set_uniform("extruder_printable_heights", extruder_printable_heights);
            shader->set_uniform("print_volume.xy_data", m_print_volume.data);
        }
        else {
            shader->set_uniform("extruder_printable_heights", extruder_printable_heights);
        }
 
        shader->set_uniform("volume_world_matrix", volume.first->world_matrix());
        shader->set_uniform("slope.actived", m_slope.isGlobalActive && !volume.first->is_modifier && !volume.first->is_wipe_tower);
        shader->set_uniform("slope.volume_world_normal_matrix", static_cast<Matrix3f>(volume.first->world_matrix().matrix().block(0, 0, 3, 3).inverse().transpose().cast<float>()));
        shader->set_uniform("slope.normal_z", support_normal_z);
        shader->set_uniform("slope.up_direction", up_direction);
 
#if ENABLE_ENVIRONMENT_MAP
        unsigned int environment_texture_id = GUI::wxGetApp().plater()->get_environment_texture_id();
        bool use_environment_texture = environment_texture_id > 0 && GUI::wxGetApp().app_config->get("use_environment_map") == "1";
        shader->set_uniform("use_environment_tex", use_environment_texture);
        if (use_environment_texture)
            glsafe(::glBindTexture(GL_TEXTURE_2D, environment_texture_id));
#endif // ENABLE_ENVIRONMENT_MAP
        glcheck();
 
    auto red_color = ColorRGBA{1.0f, 0.0f, 0.0f, 1.0f};//slice_error
        volume.first->model.set_color(volume.first->slice_error ? red_color : volume.first->render_color);
        const Transform3d model_matrix = volume.first->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);
        if (shade_translucent_filaments) {
            const bool translucent_filament = volume.first->visible && !volume.first->is_modifier && volume.first->color.is_transparent();
            shader->set_uniform("translucent_filament", translucent_filament);
            glsafe(::glBlendFunc(translucent_filament ? GL_ONE : GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
        }
        if (volume.first->depth_bias) {
            glsafe(::glEnable(GL_POLYGON_OFFSET_FILL));
            glsafe(::glPolygonOffset(1.0f, 1.0f));
        }
    //BBS: add outline related logic
        if (volume.first->selected && shader_can_outline && GUI::wxGetApp().show_outline())
            volume.first->render_with_outline(cnv_size);
        else
            volume.first->render();
        if (volume.first->depth_bias)
            glsafe(::glDisable(GL_POLYGON_OFFSET_FILL));
 
#if ENABLE_ENVIRONMENT_MAP
        if (use_environment_texture)
            glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
#endif // ENABLE_ENVIRONMENT_MAP
 
        glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
        glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
    }
 
    if (m_show_sinking_contours) {
        shader->stop_using();
        if (sink_shader != nullptr) {
            sink_shader->start_using();
            for (GLVolumeWithIdAndZ& volume : to_render) {
                // render sinking contours of hovered/displaced volumes
                if (volume.first->is_sinking() && !volume.first->is_below_printbed() &&
                    (volume.first->hover != GLVolume::HS_None || volume.first->force_sinking_contours)) {
                    glsafe(::glDepthFunc(GL_ALWAYS));
                    volume.first->render_sinking_contours();
                    glsafe(::glDepthFunc(GL_LESS));
                }
            }
            sink_shader->start_using();
        }
        shader->start_using();
    }
 
    if (disable_cullface)
        glsafe(::glEnable(GL_CULL_FACE));
 
    if (shade_translucent_filaments) {
        // the program is shared, so leave it as the other users expect
        shader->set_uniform("translucent_filament", false);
        glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
    }
    if (type == ERenderType::Transparent)
        glsafe(::glDisable(GL_BLEND));
}

References Slic3r::GUI::build_plate_tilt_up_direction(), Slic3r::GUI::OpenGLManager::get_gl_info(), get_selection_support_normal_z(), Slic3r::GLShaderProgram::get_uniform_location(), GL_ALWAYS, GL_ARRAY_BUFFER, GL_BACK, GL_BLEND, GL_CULL_FACE, GL_ELEMENT_ARRAY_BUFFER, GL_LESS, GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_POLYGON_OFFSET_FILL, GL_SRC_ALPHA, GL_TEXTURE_2D, glBindBuffer, glBindTexture, glBlendFunc, glcheck, glCullFace, glDepthFunc, glDisable, glEnable, glPolygonOffset, glsafe, Slic3r::GLVolume::HS_None, Slic3r::GUI::OpenGLManager::GLInfo::is_core_profile(), m_clipping_plane, m_color_clip_plane, m_color_clip_plane_colors, m_print_volume, m_show_sinking_contours, m_slope, m_use_color_clip_plane, m_z_range, OUTLINE_DEPTH_TEX_UNIT, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), Transparent, volumes, and Slic3r::volumes_to_render().

Here is the call graph for this function:

reset_outside_state()

void Slic3r::GLVolumeCollection::reset_outside_state

(

)

{
    for (GLVolume* volume : this->volumes)
    {
        if (volume != nullptr) {
            volume->is_outside = false;
            volume->partly_inside = false;
        }
    }
}

set_clipping_plane()

void Slic3r::GLVolumeCollection::set_clipping_plane ( const std::array< double, 4 > & coeffs )

inline

{ m_clipping_plane = coeffs; }

References m_clipping_plane.

set_color_clip_plane()

void Slic3r::GLVolumeCollection::set_color_clip_plane ( const Vec3d & cp_normal, double offset )

inline

                                                                     {
        for (int i = 0; i < 3; ++i)
            m_color_clip_plane[i] = -cp_normal[i];
        m_color_clip_plane[3] = offset;
    }

References m_color_clip_plane, and Slic3r::offset().

Here is the call graph for this function:

set_color_clip_plane_colors()

void Slic3r::GLVolumeCollection::set_color_clip_plane_colors ( const std::array< ColorRGBA, 2 > & colors )

inline

{ m_color_clip_plane_colors = colors; }

References m_color_clip_plane_colors.

set_default_slope_normal_z()

void Slic3r::GLVolumeCollection::set_default_slope_normal_z ( )

inline

{ m_slope.normal_z = -::cos(Geometry::deg2rad(90.0f - 45.0f)); }

References Slic3r::Geometry::deg2rad(), and m_slope.

Referenced by GLVolumeCollection().

Here is the call graph for this function:

Here is the caller graph for this function:

set_print_volume()

void Slic3r::GLVolumeCollection::set_print_volume ( const PrintVolume & print_volume )

inline

{ m_print_volume = print_volume; }

References m_print_volume.

set_range()

void Slic3r::GLVolumeCollection::set_range ( double low, double high )

inline

{ for (GLVolume *vol : this->volumes) vol->set_range(low, high); }

set_show_sinking_contours()

void Slic3r::GLVolumeCollection::set_show_sinking_contours ( bool show )

inline

{ m_show_sinking_contours = show; }

References m_show_sinking_contours.

set_slope_active()

void Slic3r::GLVolumeCollection::set_slope_active ( bool active )

inline

{ m_slope.active = active; }

References m_slope.

set_slope_GlobalActive()

void Slic3r::GLVolumeCollection::set_slope_GlobalActive ( bool active )

inline

{ m_slope.isGlobalActive = active; }

References m_slope.

set_slope_normal_z()

void Slic3r::GLVolumeCollection::set_slope_normal_z ( float normal_z )

inline

{ m_slope.normal_z = normal_z; }

References m_slope.

set_transparency()

void Slic3r::GLVolumeCollection::set_transparency

(

float

alpha

)

{
    for (GLVolume *volume : volumes) {
        if (volume == nullptr || volume->is_modifier || volume->is_wipe_tower || (volume->volume_idx() < 0))
            continue;
 
        volume->color.a(alpha);
    }
}

References volumes.

set_use_color_clip_plane()

void Slic3r::GLVolumeCollection::set_use_color_clip_plane ( bool use )

inline

{ m_use_color_clip_plane = use; }

References m_use_color_clip_plane.

set_z_range()

void Slic3r::GLVolumeCollection::set_z_range ( float min_z, float max_z )

inline

{ m_z_range[0] = min_z; m_z_range[1] = max_z; }

References m_z_range.

total_memory_used()

size_t Slic3r::GLVolumeCollection::total_memory_used ( ) const

inline

{ return this->cpu_memory_used() + this->gpu_memory_used(); }

References cpu_memory_used(), and gpu_memory_used().

Here is the call graph for this function:

update_colors_by_extruder()

void Slic3r::GLVolumeCollection::update_colors_by_extruder	(	const DynamicPrintConfig *	config,
		bool	is_update_alpha = true )

{
    
    using ColorItem = std::pair<std::string, ColorRGBA>;
    std::vector<ColorItem> colors;
 
    if (config->has("printer_technology") && static_cast<PrinterTechnology>(config->opt_int("printer_technology")) == ptSLA) {
        const std::string& txt_color = config->opt_string("material_colour").empty() ?
                                       print_config_def.get("material_colour")->get_default_value<ConfigOptionString>()->value :
                                       config->opt_string("material_colour");
        ColorRGBA rgba;
        if (decode_color(txt_color, rgba))
            colors.push_back({ txt_color, rgba });
    }
    else {
    if (!config->has("filament_colour")) {
              return;
        }
        const ConfigOptionStrings* filamemts_opt = dynamic_cast<const ConfigOptionStrings*>(config->option("filament_colour"));
        if (filamemts_opt == nullptr)
            return;
 
        size_t colors_count = (size_t)filamemts_opt->values.size();
        if (colors_count == 0)
            return;
        colors.resize(colors_count);
 
        for (unsigned int i = 0; i < colors_count; ++i) {
            ColorRGBA rgba;
            const std::string& fil_color = config->opt_string("filament_colour", i);
            if (decode_color(fil_color, rgba))
                colors[i] = { fil_color, rgba };
        }
    }
 
    for (GLVolume* volume : volumes) {
        if (volume == nullptr || volume->is_modifier || volume->is_wipe_tower || volume->volume_idx() < 0)
            continue;
 
        int extruder_id = volume->extruder_id - 1;
        if (extruder_id < 0 || (int)colors.size() <= extruder_id)
            extruder_id = 0;
 
        const ColorItem& color = colors[extruder_id];
        if (!color.first.empty()) {
            if (!is_update_alpha) {
                float old_a   = volume->color.a();
                volume->color = color.second;
                volume->color.a(old_a);
            } else {
                volume->color = color.second;
            }
        }
    }
}

References Slic3r::decode_color(), Slic3r::ConfigOptionResolver::has(), Slic3r::DynamicConfig::opt_int(), Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), Slic3r::print_config_def, Slic3r::ptSLA, Slic3r::ConfigOptionVector< T >::values, and volumes.

Here is the call graph for this function:

Member Data Documentation

m_clipping_plane

std::array<double, 4> Slic3r::GLVolumeCollection::m_clipping_plane

private

Referenced by get_clipping_plane(), render(), and set_clipping_plane().

m_color_clip_plane

std::array<double, 4> Slic3r::GLVolumeCollection::m_color_clip_plane

private

Referenced by render(), and set_color_clip_plane().

m_color_clip_plane_colors

std::array<ColorRGBA, 2> Slic3r::GLVolumeCollection::m_color_clip_plane_colors { ColorRGBA::RED(), ColorRGBA::BLUE() }

private

{ ColorRGBA::RED(), ColorRGBA::BLUE() };

Referenced by render(), and set_color_clip_plane_colors().

m_print_volume

PrintVolume Slic3r::GLVolumeCollection::m_print_volume

private

Referenced by render(), and set_print_volume().

m_render_volume

PrintVolume Slic3r::GLVolumeCollection::m_render_volume

private

Referenced by GLVolumeCollection().

m_show_sinking_contours

bool Slic3r::GLVolumeCollection::m_show_sinking_contours = false

private

Referenced by render(), and set_show_sinking_contours().

m_slope

Slope Slic3r::GLVolumeCollection::m_slope

private

Referenced by get_slope_normal_z(), is_slope_active(), is_slope_GlobalActive(), render(), set_default_slope_normal_z(), set_slope_active(), set_slope_GlobalActive(), and set_slope_normal_z().

m_use_color_clip_plane

bool Slic3r::GLVolumeCollection::m_use_color_clip_plane { false }

private

{ false };

Referenced by render(), and set_use_color_clip_plane().

m_z_range

std::array<float, 2> Slic3r::GLVolumeCollection::m_z_range

private

Referenced by get_z_range(), render(), and set_z_range().

volumes

GLVolumePtrs Slic3r::GLVolumeCollection::volumes

Referenced by clear(), Slic3r::GUI::create_meshes(), anonymous_namespace{SurfaceDrag.cpp}::dragging(), empty(), Slic3r::GUI::DesignSketchTool::fit_box(), Slic3r::GUI::get_first_hovered_gl_volume(), Slic3r::GUI::get_selected_gl_volume(), load_object_auxiliary(), load_object_volume(), load_real_wipe_tower_preview(), load_wipe_tower_preview(), Slic3r::GUI::GLCanvas3D::CenterOfMass::model_markers(), new_nontoolpath_volume(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), render(), Slic3r::GUI::GLCanvas3D::Labels::render(), Slic3r::GUI::GLCanvas3D::render_thumbnail_internal(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_volumes(), Slic3r::CLI::run(), set_transparency(), anonymous_namespace{SurfaceDrag.cpp}::start_dragging(), and update_colors_by_extruder().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/3DScene.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/3DScene.cpp