Slic3r::GUI::GLCanvas3D::SequentialPrintClearance Class Reference

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

Collaboration diagram for Slic3r::GUI::GLCanvas3D::SequentialPrintClearance:

Public Member Functions
void	set_polygons (const Polygons &polygons, const std::vector< std::pair< Polygon, float > > &height_polygons)
void	set_render_fill (bool render_fill)
void	set_visible (bool visible)
void	render ()

Private Attributes
GLModel	m_height_limit
GLModel	m_fill
GLModel	m_perimeter
bool	m_render_fill { true }
bool	m_visible { false }
std::vector< Pointf3s >	m_hull_2d_cache

Friends
class	GLCanvas3D

Detailed Description

Member Function Documentation

render()

void Slic3r::GUI::GLCanvas3D::SequentialPrintClearance::render

(

)

{
    const ColorRGBA FILL_COLOR = { 0.7f, 0.7f, 1.0f, 0.5f };
    const ColorRGBA NO_FILL_COLOR = { 0.75f, 0.75f, 0.75f, 0.75f };
 
    GLShaderProgram* shader = wxGetApp().get_shader("flat");
    if (shader == nullptr)
        return;
 
    shader->start_using();
 
    const Camera& camera = wxGetApp().plater()->get_camera();
    shader->set_uniform("view_model_matrix", camera.get_view_matrix());
    shader->set_uniform("projection_matrix", camera.get_projection_matrix());
 
    glsafe(::glEnable(GL_DEPTH_TEST));
    glsafe(::glDisable(GL_CULL_FACE));
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
    m_perimeter.set_color(m_render_fill ? FILL_COLOR : NO_FILL_COLOR);
    m_perimeter.render();
    m_fill.render();
    //BBS: add height limit
    m_height_limit.set_color(m_render_fill ? FILL_COLOR : NO_FILL_COLOR);
    m_height_limit.render();
 
    glsafe(::glDisable(GL_BLEND));
    glsafe(::glEnable(GL_CULL_FACE));
    glsafe(::glDisable(GL_DEPTH_TEST));
 
    shader->stop_using();
}

References Slic3r::GUI::GLCanvas3D::camera, GL_BLEND, GL_CULL_FACE, GL_DEPTH_TEST, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, glBlendFunc, glDisable, glEnable, glsafe, m_fill, m_height_limit, m_perimeter, m_render_fill, render(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

set_polygons()

void Slic3r::GUI::GLCanvas3D::SequentialPrintClearance::set_polygons	(	const Polygons &	polygons,
		const std::vector< std::pair< Polygon, float > > &	height_polygons )

{
    //BBS: add height limit logic
    m_height_limit.reset();
    m_perimeter.reset();
    m_fill.reset();
    if (!polygons.empty()) {
        if (m_render_fill) {
            GLModel::Geometry fill_data;
            fill_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3 };
            fill_data.color  = { 0.8f, 0.8f, 1.0f, 0.5f };
 
            // vertices + indices
            const ExPolygons polygons_union = union_ex(polygons);
            unsigned int vertices_counter = 0;
            for (const ExPolygon& poly : polygons_union) {
                const std::vector<Vec3d> triangulation = triangulate_expolygon_3d(poly);
                fill_data.reserve_vertices(fill_data.vertices_count() + triangulation.size());
                fill_data.reserve_indices(fill_data.indices_count() + triangulation.size());
                for (const Vec3d& v : triangulation) {
                    fill_data.add_vertex((Vec3f)(v.cast<float>() + 0.0125f * Vec3f::UnitZ())); // add a small positive z to avoid z-fighting
                    ++vertices_counter;
                    if (vertices_counter % 3 == 0)
                        fill_data.add_triangle(vertices_counter - 3, vertices_counter - 2, vertices_counter - 1);
                }
            }
 
            m_fill.init_from(std::move(fill_data));
        }
 
        m_perimeter.init_from(polygons, 0.025f); // add a small positive z to avoid z-fighting
    }
 
    //BBS: add the height limit compute logic
    if (!height_polygons.empty()) {
        GLModel::Geometry height_fill_data;
        height_fill_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3 };
        height_fill_data.color  = {0.8f, 0.8f, 1.0f, 0.5f};
 
        // vertices + indices
        unsigned int vertices_counter = 0;
        for (const auto &poly : height_polygons) {
            ExPolygon                ex_poly(poly.first);
            const std::vector<Vec3d> height_triangulation = triangulate_expolygon_3d(ex_poly);
            for (const Vec3d &v : height_triangulation) {
                Vec3f point{(float) v.x(), (float) v.y(), poly.second};
                height_fill_data.add_vertex(point);
                ++vertices_counter;
                if (vertices_counter % 3 == 0)
                    height_fill_data.add_triangle(vertices_counter - 3, vertices_counter - 2, vertices_counter - 1);
            }
        }
 
        m_height_limit.init_from(std::move(height_fill_data));
    }
}

References Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::color, Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::Geometry::indices_count(), m_fill, m_height_limit, m_perimeter, m_render_fill, Slic3r::GUI::GLModel::Geometry::P3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), set_polygons(), Slic3r::GUI::GLModel::Geometry::Triangles, Slic3r::triangulate_expolygon_3d(), Slic3r::union_ex(), and Slic3r::GUI::GLModel::Geometry::vertices_count().

Referenced by set_polygons().

Here is the call graph for this function:

Here is the caller graph for this function:

set_render_fill()

void Slic3r::GUI::GLCanvas3D::SequentialPrintClearance::set_render_fill ( bool render_fill )

inline

{ m_render_fill = render_fill; }

References m_render_fill.

set_visible()

void Slic3r::GUI::GLCanvas3D::SequentialPrintClearance::set_visible ( bool visible )

inline

{ m_visible = visible; }

References m_visible.

Friends And Related Symbol Documentation

GLCanvas3D

friend class GLCanvas3D

friend

References GLCanvas3D.

Referenced by GLCanvas3D.

Member Data Documentation

m_fill

GLModel Slic3r::GUI::GLCanvas3D::SequentialPrintClearance::m_fill

private

Referenced by render(), and set_polygons().

m_height_limit

GLModel Slic3r::GUI::GLCanvas3D::SequentialPrintClearance::m_height_limit

private

Referenced by render(), and set_polygons().

m_hull_2d_cache

std::vector<Pointf3s> Slic3r::GUI::GLCanvas3D::SequentialPrintClearance::m_hull_2d_cache

private

m_perimeter

GLModel Slic3r::GUI::GLCanvas3D::SequentialPrintClearance::m_perimeter

private

Referenced by render(), and set_polygons().

m_render_fill

bool Slic3r::GUI::GLCanvas3D::SequentialPrintClearance::m_render_fill { true }

private

{ true };

Referenced by render(), set_polygons(), and set_render_fill().

m_visible

bool Slic3r::GUI::GLCanvas3D::SequentialPrintClearance::m_visible { false }

private

{ false };

Referenced by set_visible().

---

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

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