Slic3r::GLVolumeCollection Class Reference

#include <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)
int	load_object_volume (const ModelObject *model_object, int obj_idx, int volume_idx, int instance_idx)
int	load_wipe_tower_preview (float pos_x, float pos_y, float width, float depth, const std::vector< std::pair< float, float > > &z_and_depth_pairs, float height, float cone_angle, float rotation_angle, bool size_unknown, float brim_width)
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)
GLVolume *	new_toolpath_volume (const ColorRGBA &rgba)
GLVolume *	new_nontoolpath_volume (const ColorRGBA &rgba)
void	render (ERenderType type, bool disable_cullface, const Transform3d &view_matrix, const Transform3d &projection_matrix, std::function< bool(const GLVolume &)> filter_func=std::function< bool(const GLVolume &)>()) const
void	clear ()
bool	empty () const
void	set_range (double low, double high)
void	set_use_raycasters (bool value)
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_active () const
void	set_slope_active (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)
void	set_show_non_manifold_edges (bool show)
void	reset_outside_state ()
void	update_colors_by_extruder (const DynamicPrintConfig *config)
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

Public Attributes
GLVolumePtrs	volumes

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

Private Attributes
PrintVolume	m_print_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 }
bool	m_show_non_manifold_edges { true }
bool	m_use_raycasters { true }

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 }
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(); }

References set_default_slope_normal_z().

Here is the call 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

Member Function Documentation

clear()

void Slic3r::GLVolumeCollection::clear ( )

inline

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

References volumes.

Referenced by ~GLVolumeCollection(), Slic3r::GUI::GCodeViewer::reset(), Slic3r::GUI::GLCanvas3D::reset_volumes(), and Slic3r::GUI::GLGizmoSlaBase::update_volumes().

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

References volumes.

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 Slic3r::GUI::GLCanvas3D::check_volumes_outside_state(), Slic3r::GUI::GLCanvas3D::on_char(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLCanvas3D::render(), Slic3r::GUI::GCodeViewer::render_shells(), and Slic3r::GUI::GLCanvas3D::reset_volumes().

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(), EPSILON, and volumes.

Referenced by Slic3r::GUI::GLCanvas3D::get_volumes_print_zs().

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, and Slic3r::GLVolumeCollection::Slope::normal_z.

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

References volumes.

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 Slic3r::GLVolumeCollection::Slope::active, and m_slope.

Referenced by Slic3r::GUI::GLCanvas3D::Slope::is_used().

Here is the caller graph for this function:

load_object()

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

{
    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));
    return volumes_idx;
}

References Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::GLCanvas3D::load_object(), and Slic3r::GUI::GCodeViewer::load_shells().

Here is the caller 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
	)

{
    if (print_object->get_mesh_to_print() == nullptr)
        return;
    const Transform3d mesh_trafo_inv = print_object->trafo().inverse();
 
    auto add_volume = [this, timestamp](int obj_idx, int inst_idx, const ModelInstance& model_instance, SLAPrintObjectStep step,
        const TriangleMesh& mesh, const ColorRGBA& color, std::optional<const TriangleMesh> convex_hull = std::nullopt) {
        if (mesh.empty())
            return;
 
        GLVolume& v = *this->volumes.emplace_back(new GLVolume(color));
#if ENABLE_SMOOTH_NORMALS
        v.model.init_from(mesh, true);
#else
        v.model.init_from(mesh);
        v.model.set_color(color);
        v.mesh_raycaster = std::make_unique<GUI::MeshRaycaster>(std::make_shared<const TriangleMesh>(mesh));
#endif // ENABLE_SMOOTH_NORMALS
        v.composite_id = GLVolume::CompositeID(obj_idx, -int(step), inst_idx);
        v.geometry_id = std::pair<size_t, size_t>(timestamp, model_instance.id().id);
        if (convex_hull.has_value())
            v.set_convex_hull(*convex_hull);
        v.is_modifier = false;
        v.shader_outside_printer_detection_enabled = (step == slaposSupportTree || step == slaposDrillHoles);
        v.set_instance_transformation(model_instance.get_transformation());
    };
 
    if (milestone == SLAPrintObjectStep::slaposDrillHoles) {
        if (print_object->get_parts_to_slice().size() > 1) {
            // Get the mesh.
            TriangleMesh backend_mesh;
            std::shared_ptr<const indexed_triangle_set> preview_mesh_ptr = print_object->get_mesh_to_print();
            if (preview_mesh_ptr != nullptr)
                backend_mesh = TriangleMesh(*preview_mesh_ptr);
            if (!backend_mesh.empty()) {
                backend_mesh.transform(mesh_trafo_inv);
                TriangleMesh convex_hull = backend_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];
                    add_volume(obj_idx, (int)instance_idx.first, model_instance, slaposDrillHoles, backend_mesh, GLVolume::MODEL_COLOR[0], convex_hull);
                }
            }
        }
    }
 
    // Get the support mesh.
    if (milestone == SLAPrintObjectStep::slaposSupportTree) {
        TriangleMesh supports_mesh = print_object->support_mesh();
        if (!supports_mesh.empty()) {
            supports_mesh.transform(mesh_trafo_inv);
            TriangleMesh convex_hull = supports_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];
                add_volume(obj_idx, (int)instance_idx.first, model_instance, slaposSupportTree, supports_mesh, GLVolume::SLA_SUPPORT_COLOR, convex_hull);
            }
        }
    }
 
    // Get the pad mesh.
    if (milestone == SLAPrintObjectStep::slaposPad) {
        TriangleMesh pad_mesh = print_object->pad_mesh();
        if (!pad_mesh.empty()) {
            pad_mesh.transform(mesh_trafo_inv);
            TriangleMesh convex_hull = pad_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];
                add_volume(obj_idx, (int)instance_idx.first, model_instance, slaposPad, pad_mesh, GLVolume::SLA_PAD_COLOR, convex_hull);
            }
        }
    }
}

References Slic3r::GLVolume::composite_id, Slic3r::TriangleMesh::convex_hull_3d(), Slic3r::TriangleMesh::empty(), Slic3r::GLVolume::geometry_id, Slic3r::SLAPrintObject::get_mesh_to_print(), Slic3r::SLAPrintObject::get_parts_to_slice(), Slic3r::GUI::GLModel::init_from(), Slic3r::ModelObject::instances, Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::inverse(), Slic3r::GLVolume::mesh_raycaster, Slic3r::GLVolume::model, Slic3r::GLVolume::MODEL_COLOR, Slic3r::PrintObjectBase::model_object(), Slic3r::SLAPrintObject::pad_mesh(), 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::slaposDrillHoles, Slic3r::slaposPad, Slic3r::slaposSupportTree, Slic3r::SLAPrintObject::support_mesh(), Slic3r::SLAPrintObject::trafo(), Slic3r::TriangleMesh::transform(), and volumes.

Referenced by Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller 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 ModelVolume   *model_volume = model_object->volumes[volume_idx];
    const int            extruder_id  = model_volume->extruder_id();
    const ModelInstance *instance     = model_object->instances[instance_idx];
    std::shared_ptr<const TriangleMesh> mesh = model_volume->mesh_ptr();
    this->volumes.emplace_back(new GLVolume());
    GLVolume& v = *this->volumes.back();
    v.set_color(color_from_model_volume(*model_volume));
    // apply printable value from the instance
    v.printable = instance->printable;
#if ENABLE_SMOOTH_NORMALS
    v.model.init_from(*mesh, true);
    if (m_use_raycasters)
      v.mesh_raycaster = std::make_unique<GUI::MeshRaycaster>(mesh);
#else
    v.model.init_from(*mesh);
    if (m_use_raycasters)
      v.mesh_raycaster = std::make_unique<GUI::MeshRaycaster>(mesh);
#endif // ENABLE_SMOOTH_NORMALS
    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();
    v.set_instance_transformation(instance->get_transformation());
    v.set_volume_transformation(model_volume->get_transformation());
 
    return int(this->volumes.size() - 1);
}

References Slic3r::color_from_model_volume(), Slic3r::GLVolume::composite_id, Slic3r::ModelVolume::extruder_id(), Slic3r::GLVolume::extruder_id, Slic3r::ModelVolume::get_convex_hull_shared_ptr(), Slic3r::ModelVolume::get_transformation(), Slic3r::ModelInstance::get_transformation(), Slic3r::GUI::GLModel::init_from(), Slic3r::ModelObject::instances, Slic3r::ModelVolume::is_model_part(), m_use_raycasters, Slic3r::ModelVolume::mesh_ptr(), Slic3r::GLVolume::mesh_raycaster, Slic3r::GLVolume::model, Slic3r::ModelInstance::printable, Slic3r::GLVolume::set_color(), Slic3r::GLVolume::set_convex_hull(), Slic3r::GLVolume::set_instance_transformation(), Slic3r::GLVolume::set_volume_transformation(), Slic3r::ModelObject::volumes, and volumes.

Referenced by Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller graph for this function:

load_wipe_tower_preview()

int Slic3r::GLVolumeCollection::load_wipe_tower_preview	(	float	pos_x,
		float	pos_y,
		float	width,
		float	depth,
		const std::vector< std::pair< float, float > > &	z_and_depth_pairs,
		float	height,
		float	cone_angle,
		float	rotation_angle,
		bool	size_unknown,
		float	brim_width
	)

{
    if (height == 0.0f)
        height = 0.1f;
 
    static const float brim_height = 0.2f;
//    const float scaled_brim_height = brim_height / height;
 
    TriangleMesh mesh;
    ColorRGBA color = ColorRGBA::DARK_YELLOW();
 
    // In case we don't know precise dimensions of the wipe tower yet, we'll draw
    // the box with different color with one side jagged:
    if (size_unknown) {
        color.r(0.9f);
        color.g(0.6f);
 
        // Too narrow tower would interfere with the teeth. The estimate is not precise anyway.
        depth = std::max(depth, 10.f);
        float min_width = 30.f;
 
        // We'll now create the box with jagged edge. y-coordinates of the pre-generated model
        // are shifted so that the front edge has y=0 and centerline of the back edge has y=depth:
        float out_points_idx[][3] = { { 0, -depth, 0 }, { 0, 0, 0 }, { 38.453f, 0, 0 }, { 61.547f, 0, 0 }, { 100.0f, 0, 0 }, { 100.0f, -depth, 0 }, { 55.7735f, -10.0f, 0 }, { 44.2265f, 10.0f, 0 },
            { 38.453f, 0, 1 }, { 0, 0, 1 }, { 0, -depth, 1 }, { 100.0f, -depth, 1 }, { 100.0f, 0, 1 }, { 61.547f, 0, 1 }, { 55.7735f, -10.0f, 1 }, { 44.2265f, 10.0f, 1 } };
        static constexpr const int out_facets_idx[][3] = {
            { 0, 1, 2 }, { 3, 4, 5 }, { 6, 5, 0 }, { 3, 5, 6 }, { 6, 2, 7 }, { 6, 0, 2 }, { 8, 9, 10 }, { 11, 12, 13 }, { 10, 11, 14 }, { 14, 11, 13 }, { 15, 8, 14 },
            { 8, 10, 14 }, { 3, 12, 4 }, { 3, 13, 12 }, { 6, 13, 3 }, { 6, 14, 13 }, { 7, 14, 6 }, { 7, 15, 14 }, { 2, 15, 7 }, { 2, 8, 15 }, { 1, 8, 2 }, { 1, 9, 8 },
            { 0, 9, 1 }, { 0, 10, 9 }, { 5, 10, 0 }, { 5, 11, 10 }, { 4, 11, 5 }, { 4, 12, 11 } };
        indexed_triangle_set its;
        for (int i = 0; i < 16; ++i)
            its.vertices.emplace_back(out_points_idx[i][0] / (100.f / min_width), out_points_idx[i][1] + depth, out_points_idx[i][2]);
        its.indices.reserve(28);
        for (const int* face : out_facets_idx)
            its.indices.emplace_back(face);
        TriangleMesh tooth_mesh(std::move(its));
 
        // We have the mesh ready. It has one tooth and width of min_width. We will now
        // append several of these together until we are close to the required width
        // of the block. Than we can scale it precisely.
        size_t n = std::max(1, int(width / min_width)); // How many shall be merged?
        for (size_t i = 0; i < n; ++i) {
            mesh.merge(tooth_mesh);
            tooth_mesh.translate(min_width, 0.f, 0.f);
        }
 
        mesh.scale(Vec3f(width / (n * min_width), 1.f, height)); // Scaling to proper width
    }
    else {
        for (size_t i=1; i<z_and_depth_pairs.size(); ++i) {
            TriangleMesh m = make_cube(width, z_and_depth_pairs[i-1].second, z_and_depth_pairs[i].first-z_and_depth_pairs[i-1].first);
            m.translate(0.f, -z_and_depth_pairs[i-1].second/2.f + z_and_depth_pairs[0].second/2.f, z_and_depth_pairs[i-1].first);
            mesh.merge(m);
        }
    }
 
    // We'll make another mesh to show the brim (fixed layer height):
    TriangleMesh brim_mesh = make_cube(width + 2.f * brim_width, depth + 2.f * brim_width, 0.2f);
    brim_mesh.translate(-brim_width, -brim_width, 0.f);
    mesh.merge(brim_mesh);
 
    // Now the stabilization cone and its base.
    const auto [R, scale_x] = WipeTower::get_wipe_tower_cone_base(width, height, depth, cone_angle);
    if (R > 0.) {
        TriangleMesh cone_mesh(its_make_cone(R, height));
        cone_mesh.scale(Vec3f(1.f/scale_x, 1.f, 1.f));
 
        TriangleMesh disk_mesh(its_make_cylinder(R, brim_height));
        disk_mesh.scale(Vec3f(1. / scale_x, 1., 1.)); // Now it matches the base, which may be elliptic.
        disk_mesh.scale(Vec3f(1.f + scale_x*brim_width/R, 1.f + brim_width/R, 1.f)); // Scale so the brim is not deformed.
        cone_mesh.merge(disk_mesh);
        cone_mesh.translate(width / 2., depth / 2., 0.);
        mesh.merge(cone_mesh);
    }
 
 
    volumes.emplace_back(new GLVolume(color));
    GLVolume& v = *volumes.back();
#if ENABLE_OPENGL_ES
    if (out_mesh != nullptr)
        *out_mesh = mesh;
#endif // ENABLE_OPENGL_ES
    v.model.init_from(mesh);
    v.model.set_color(color);
    v.mesh_raycaster = std::make_unique<GUI::MeshRaycaster>(std::make_shared<const TriangleMesh>(mesh));
    v.set_convex_hull(mesh.convex_hull_3d());
    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(INT_MAX, 0, 0);
    v.geometry_id.first = 0;
    v.geometry_id.second = wipe_tower_instance_id().id;
    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::ColorRGBA::DARK_YELLOW(), Slic3r::ColorRGBA::g(), Slic3r::GLVolume::geometry_id, Slic3r::WipeTower::get_wipe_tower_cone_base(), Slic3r::ObjectID::id, indexed_triangle_set::indices, Slic3r::GUI::GLModel::init_from(), Slic3r::its_make_cone(), Slic3r::its_make_cylinder(), M_PI, Slic3r::make_cube(), Slic3r::TriangleMesh::merge(), Slic3r::GLVolume::mesh_raycaster, Slic3r::GLVolume::model, Slic3r::ColorRGBA::r(), Slic3r::TriangleMesh::scale(), Slic3r::GUI::GLModel::set_color(), Slic3r::GLVolume::set_convex_hull(), Slic3r::GLVolume::set_volume_offset(), Slic3r::GLVolume::set_volume_rotation(), Slic3r::TriangleMesh::translate(), indexed_triangle_set::vertices, and Slic3r::wipe_tower_instance_id().

Referenced by Slic3r::GUI::GCodeViewer::load_shells(), and Slic3r::GUI::GLCanvas3D::reload_scene().

Here is the call graph for this function:

Here is the caller 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

render()

void Slic3r::GLVolumeCollection::render	(	GLVolumeCollection::ERenderType	type,
		bool	disable_cullface,
		const Transform3d &	view_matrix,
		const Transform3d &	projection_matrix,
		std::function< bool(const GLVolume &)>	filter_func = std::function<bool(const GLVolume&)>()
	)		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 ENABLE_GL_CORE_PROFILE
    GLShaderProgram* edges_shader = GUI::OpenGLManager::get_gl_info().is_core_profile() ? GUI::wxGetApp().get_shader("dashed_thick_lines") : GUI::wxGetApp().get_shader("flat");
#else
    GLShaderProgram* edges_shader = GUI::wxGetApp().get_shader("flat");
#endif // ENABLE_GL_CORE_PROFILE
 
    if (type == ERenderType::Transparent) {
        glsafe(::glEnable(GL_BLEND));
        glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
        glsafe(::glDepthMask(false));
    }
 
    glsafe(::glCullFace(GL_BACK));
    if (disable_cullface)
        glsafe(::glDisable(GL_CULL_FACE));
 
    for (GLVolumeWithIdAndZ& volume : to_render) {
        const Transform3d& world_matrix = volume.first->world_matrix();
        volume.first->set_render_color(true);
 
        // 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();
 
        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]);
        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);
        shader->set_uniform("volume_world_matrix", world_matrix);
        shader->set_uniform("slope.actived", m_slope.active && !volume.first->is_modifier && !volume.first->is_wipe_tower);
        shader->set_uniform("slope.volume_world_normal_matrix", static_cast<Matrix3f>(world_matrix.matrix().block(0, 0, 3, 3).inverse().transpose().cast<float>()));
        shader->set_uniform("slope.normal_z", m_slope.normal_z);
 
#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_bool("use_environment_map");
        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();
 
        volume.first->model.set_color(volume.first->render_color);
        const Transform3d model_matrix = 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);
        volume.first->render();
 
#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();
    }
 
    shader->stop_using();
    if (edges_shader != nullptr) {
        edges_shader->start_using();
        if (m_show_non_manifold_edges && GUI::wxGetApp().app_config->get_bool("non_manifold_edges")) {
            for (GLVolumeWithIdAndZ& volume : to_render) {
                volume.first->render_non_manifold_edges();
            }
        }
        edges_shader->stop_using();
    }
    shader->start_using();
 
    if (disable_cullface)
        glsafe(::glEnable(GL_CULL_FACE));
 
    if (type == ERenderType::Transparent) {
        glsafe(::glDisable(GL_BLEND));
        glsafe(::glDepthMask(true));
    }
}

References Slic3r::GLVolumeCollection::Slope::active, Slic3r::GLVolumeCollection::PrintVolume::data, Slic3r::GUI::OpenGLManager::get_gl_info(), glcheck, 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_non_manifold_edges, m_show_sinking_contours, m_slope, m_use_color_clip_plane, m_z_range, Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::matrix(), Slic3r::GLVolumeCollection::Slope::normal_z, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), Transparent, Slic3r::GLVolumeCollection::PrintVolume::type, volumes, Slic3r::volumes_to_render(), and Slic3r::GLVolumeCollection::PrintVolume::zs.

Referenced by Slic3r::GUI::GCodeViewer::render_shells(), and Slic3r::GUI::GLGizmoSlaBase::render_volumes().

Here is the call graph for this function:

Here is the caller 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;
    }
}

References volumes.

set_clipping_plane()

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

inline

{ m_clipping_plane = coeffs; }

References m_clipping_plane.

Referenced by Slic3r::GUI::GLGizmoSlaBase::render_volumes().

Here is the caller graph for this function:

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().

Referenced by Slic3r::GUI::GLCanvas3D::set_color_clip_plane().

Here is the call graph for this function:

Here is the caller 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.

Referenced by Slic3r::GUI::GLCanvas3D::set_color_clip_plane_colors().

Here is the caller graph for this function:

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 cos(), Slic3r::Geometry::deg2rad(), m_slope, and Slic3r::GLVolumeCollection::Slope::normal_z.

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

References volumes.

Referenced by Slic3r::GUI::GLCanvas3D::set_volumes_z_range().

Here is the caller graph for this function:

set_show_non_manifold_edges()

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

inline

{ m_show_non_manifold_edges = show; }

References m_show_non_manifold_edges.

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 Slic3r::GLVolumeCollection::Slope::active, and m_slope.

Referenced by Slic3r::GUI::GLCanvas3D::Slope::use().

Here is the caller graph for this function:

set_slope_normal_z()

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

inline

{ m_slope.normal_z = normal_z; }

References m_slope, and Slic3r::GLVolumeCollection::Slope::normal_z.

Referenced by Slic3r::GUI::GLCanvas3D::Slope::set_normal_angle().

Here is the caller graph for this function:

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.

Referenced by Slic3r::GUI::GLCanvas3D::set_use_color_clip_plane().

Here is the caller graph for this function:

set_use_raycasters()

void Slic3r::GLVolumeCollection::set_use_raycasters ( bool  value )

inline

{ m_use_raycasters = value; }

References m_use_raycasters.

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

Here is the caller graph for this function:

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

)

{
    using ColorItem = std::pair<std::string, ColorRGB>;
    std::vector<ColorItem> colors;
 
    if (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");
        ColorRGB rgb;
        if (decode_color(txt_color, rgb))
            colors.push_back({ txt_color, rgb });
    }
    else {
        const ConfigOptionStrings* extruders_opt = dynamic_cast<const ConfigOptionStrings*>(config->option("extruder_colour"));
        if (extruders_opt == nullptr)
            return;
 
        const ConfigOptionStrings* filamemts_opt = dynamic_cast<const ConfigOptionStrings*>(config->option("filament_colour"));
        if (filamemts_opt == nullptr)
            return;
 
        size_t colors_count = std::max(extruders_opt->values.size(), filamemts_opt->values.size());
        if (colors_count == 0)
            return;
        colors.resize(colors_count);
 
        for (unsigned int i = 0; i < colors_count; ++i) {
            const std::string& ext_color = config->opt_string("extruder_colour", i);
            ColorRGB rgb;
            if (decode_color(ext_color, rgb))
                colors[i] = { ext_color, rgb };
            else {
                const std::string& fil_color = config->opt_string("filament_colour", i);
                if (decode_color(fil_color, rgb))
                    colors[i] = { fil_color, rgb };
            }
        }
    }
 
    for (GLVolume* volume : volumes) {
        if (volume == nullptr || volume->is_modifier || volume->is_wipe_tower || volume->is_sla_pad() || volume->is_sla_support())
            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())
            volume->color = to_rgba(color.second, volume->color.a());
    }
}

References Slic3r::decode_color(), Slic3r::ConfigDef::get(), Slic3r::ConfigOptionDef::get_default_value(), Slic3r::ConfigBase::opt_int(), Slic3r::ConfigBase::opt_string(), Slic3r::ConfigBase::option(), Slic3r::print_config_def, Slic3r::ptSLA, Slic3r::to_rgba(), Slic3r::ConfigOptionVector< T >::values, and volumes.

Referenced by Slic3r::GUI::GCodeViewer::update_shells_color_by_extruder(), and Slic3r::GUI::GLCanvas3D::update_volumes_colors_by_extruder().

Here is the call graph for this function:

Here is the caller 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

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_show_non_manifold_edges

bool Slic3r::GLVolumeCollection::m_show_non_manifold_edges { true }

private

Referenced by render(), and set_show_non_manifold_edges().

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(), render(), set_default_slope_normal_z(), set_slope_active(), and set_slope_normal_z().

m_use_color_clip_plane

bool Slic3r::GLVolumeCollection::m_use_color_clip_plane { false }

private

Referenced by render(), and set_use_color_clip_plane().

m_use_raycasters

bool Slic3r::GLVolumeCollection::m_use_raycasters { true }

private

Referenced by load_object_volume(), and set_use_raycasters().

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 Slic3r::GUI::GLCanvas3D::GLCanvas3D(), Slic3r::GUI::GLCanvas3D::_picking_pass(), Slic3r::GUI::GLCanvas3D::_rectangular_selection_picking_pass(), Slic3r::GUI::GLCanvas3D::_render_thumbnail_internal(), Slic3r::GUI::GLCanvas3D::check_volumes_outside_state(), clear(), cpu_memory_used(), Slic3r::GUI::create_meshes(), Slic3r::GUI::GLCanvas3D::detect_sla_view_type(), Slic3r::GUI::GLCanvas3D::do_mirror(), Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::GUI::GLCanvas3D::do_reset_skew(), Slic3r::GUI::GLCanvas3D::do_rotate(), Slic3r::GUI::GLCanvas3D::do_scale(), empty(), Slic3r::GUI::GLCanvas3D::ensure_on_bed(), Slic3r::GUI::generate_thumbnail_from_model(), get_current_print_zs(), Slic3r::GUI::get_first_hovered_gl_volume(), Slic3r::GUI::get_selected_gl_volume(), Slic3r::GUI::GLCanvas3D::get_volumes_count(), Slic3r::GUI::GLCanvas3D::get_wipe_tower_info(), gpu_memory_used(), Slic3r::GUI::GLCanvas3D::is_object_sinking(), load_object_auxiliary(), load_object_volume(), Slic3r::GUI::GCodeViewer::load_shells(), new_nontoolpath_volume(), Slic3r::GUI::GLCanvas3D::on_mouse(), Slic3r::GUI::GLGizmoEmboss::on_mouse_change_selection(), Slic3r::GUI::on_mouse_surface_drag(), Slic3r::GUI::GLGizmoSlaBase::register_volume_raycasters_for_picking(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::GLCanvas3D::Labels::render(), render(), Slic3r::GUI::GLGizmoSlaBase::render_volumes(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_volumes(), reset_outside_state(), set_range(), Slic3r::GUI::GLCanvas3D::set_sla_view_type(), Slic3r::GUI::GLCanvas3D::set_sla_view_type(), Slic3r::GUI::GLCanvas3D::toggle_model_objects_visibility(), Slic3r::GUI::GLCanvas3D::toggle_sla_auxiliaries_visibility(), Slic3r::GUI::GLGizmoSlaBase::unproject_on_mesh(), update_colors_by_extruder(), Slic3r::GUI::GLCanvas3D::update_instance_printable_state_for_object(), Slic3r::GUI::GLCanvas3D::update_sequential_clearance(), Slic3r::GUI::GLGizmoSlaBase::update_volumes(), and Slic3r::GUI::GLCanvas3D::volumes_bounding_box().

---

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

• src/slic3r/GUI/3DScene.hpp
• src/slic3r/GUI/3DScene.cpp