Slic3r::GUI::GLSelectionRectangle Class Reference

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

Collaboration diagram for Slic3r::GUI::GLSelectionRectangle:

Public Types
enum	EState { Off , Select , Deselect }

Public Member Functions
void	start_dragging (const Vec2d &mouse_position, EState state)
void	dragging (const Vec2d &mouse_position)
std::vector< unsigned int >	contains (const std::vector< Vec3d > &points) const
void	stop_dragging ()
void	render (const GLCanvas3D &canvas)
bool	is_dragging () const
EState	get_state () const
float	get_width () const
float	get_height () const
float	get_left () const
float	get_right () const
float	get_top () const
float	get_bottom () const

Private Attributes
EState	m_state { Off }
Vec2d	m_start_corner { Vec2d::Zero() }
Vec2d	m_end_corner { Vec2d::Zero() }
GLModel	m_rectangle
Vec2d	m_old_start_corner { Vec2d::Zero() }
Vec2d	m_old_end_corner { Vec2d::Zero() }

Detailed Description

Member Enumeration Documentation

EState

enum Slic3r::GUI::GLSelectionRectangle::EState

Enumerator
Off
Select
Deselect

                {
            Off,
            Select,
            Deselect
    };

Member Function Documentation

contains()

std::vector< unsigned int > Slic3r::GUI::GLSelectionRectangle::contains

(

const std::vector< Vec3d > &

points

)

const

    {
        std::vector<unsigned int> out;
 
        // bounding box created from the rectangle corners - will take care of order of the corners
        const BoundingBox rectangle(Points{ Point(m_start_corner.cast<coord_t>()), Point(m_end_corner.cast<coord_t>()) });
 
        // Iterate over all points and determine whether they're in the rectangle.
        const Camera &camera = wxGetApp().plater()->get_camera();
        Points points_2d = CameraUtils::project(camera, points);
        unsigned int size = static_cast<unsigned int>(points.size());
        for (unsigned int i = 0; i< size; ++i)
            if (rectangle.contains(points_2d[i]))
                out.push_back(i);
 
        return out;
    }

References m_end_corner, m_start_corner, and Slic3r::GUI::CameraUtils::project().

Here is the call graph for this function:

dragging()

void Slic3r::GUI::GLSelectionRectangle::dragging

(

const Vec2d &

mouse_position

)

    {
        if (!is_dragging())
            return;
 
        m_end_corner = mouse_position;
    }

References is_dragging(), and m_end_corner.

Here is the call graph for this function:

get_bottom()

float Slic3r::GUI::GLSelectionRectangle::get_bottom ( ) const

inline

{ return std::min(m_start_corner.y(), m_end_corner.y()); }

References m_end_corner, and m_start_corner.

Referenced by render().

Here is the caller graph for this function:

get_height()

float Slic3r::GUI::GLSelectionRectangle::get_height ( ) const

inline

{ return std::abs(m_start_corner.y() - m_end_corner.y()); }

References m_end_corner, and m_start_corner.

get_left()

float Slic3r::GUI::GLSelectionRectangle::get_left ( ) const

inline

{ return std::min(m_start_corner.x(), m_end_corner.x()); }

References m_end_corner, and m_start_corner.

Referenced by render().

Here is the caller graph for this function:

get_right()

float Slic3r::GUI::GLSelectionRectangle::get_right ( ) const

inline

{ return std::max(m_start_corner.x(), m_end_corner.x()); }

References m_end_corner, and m_start_corner.

Referenced by render().

Here is the caller graph for this function:

get_state()

EState Slic3r::GUI::GLSelectionRectangle::get_state ( ) const

inline

{ return m_state; }

References m_state.

get_top()

float Slic3r::GUI::GLSelectionRectangle::get_top ( ) const

inline

{ return std::max(m_start_corner.y(), m_end_corner.y()); }

References m_end_corner, and m_start_corner.

Referenced by render().

Here is the caller graph for this function:

get_width()

float Slic3r::GUI::GLSelectionRectangle::get_width ( ) const

inline

{ return std::abs(m_start_corner.x() - m_end_corner.x()); }

References m_end_corner, and m_start_corner.

is_dragging()

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

inline

{ return m_state != Off; }

References m_state, and Off.

Referenced by dragging(), render(), start_dragging(), and stop_dragging().

Here is the caller graph for this function:

render()

void Slic3r::GUI::GLSelectionRectangle::render

(

const GLCanvas3D &

canvas

)

    {
        if (!is_dragging())
            return;
 
        const Size cnv_size = canvas.get_canvas_size();
        const float cnv_width = (float)cnv_size.get_width();
        const float cnv_height = (float)cnv_size.get_height();
        if (cnv_width == 0.0f || cnv_height == 0.0f)
            return;
 
        const float cnv_inv_width = 1.0f / cnv_width;
        const float cnv_inv_height = 1.0f / cnv_height;
        const float left = 2.0f * (get_left() * cnv_inv_width - 0.5f);
        const float right = 2.0f * (get_right() * cnv_inv_width - 0.5f);
        const float top = -2.0f * (get_top() * cnv_inv_height - 0.5f);
        const float bottom = -2.0f * (get_bottom() * cnv_inv_height - 0.5f);
        
#if !SLIC3R_OPENGL_ES
        if (!OpenGLManager::get_gl_info().is_core_profile())
            glsafe(::glLineWidth(1.5f));
#endif // !SLIC3R_OPENGL_ES
 
        glsafe(::glDisable(GL_DEPTH_TEST));
 
#if !SLIC3R_OPENGL_ES
        if (!OpenGLManager::get_gl_info().is_core_profile()) {
            glsafe(::glPushAttrib(GL_ENABLE_BIT));
            glsafe(::glLineStipple(4, 0xAAAA));
            glsafe(::glEnable(GL_LINE_STIPPLE));
        }
#endif // !SLIC3R_OPENGL_ES
 
#if SLIC3R_OPENGL_ES
        GLShaderProgram* shader = wxGetApp().get_shader("dashed_lines");
#else
        GLShaderProgram* shader = OpenGLManager::get_gl_info().is_core_profile() ? wxGetApp().get_shader("dashed_thick_lines") : wxGetApp().get_shader("flat");
#endif // SLIC3R_OPENGL_ES
        if (shader != nullptr) {
            shader->start_using();
 
            if (!m_rectangle.is_initialized() || !m_old_start_corner.isApprox(m_start_corner) || !m_old_end_corner.isApprox(m_end_corner)) {
                m_old_start_corner = m_start_corner;
                m_old_end_corner = m_end_corner;
                m_rectangle.reset();
 
                GLModel::Geometry init_data;
#if !SLIC3R_OPENGL_ES
                if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
                    init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P4 };
                    init_data.reserve_vertices(5);
                    init_data.reserve_indices(8);
#if !SLIC3R_OPENGL_ES
                }
                else {
                    init_data.format = { GLModel::Geometry::EPrimitiveType::LineLoop, GLModel::Geometry::EVertexLayout::P2 };
                    init_data.reserve_vertices(4);
                    init_data.reserve_indices(4);
                }
#endif // !SLIC3R_OPENGL_ES
 
                // vertices
#if !SLIC3R_OPENGL_ES
                if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
                    const float width = right - left;
                    const float height = top - bottom;
                    float perimeter = 0.0f;
 
                    init_data.add_vertex(Vec4f(left, bottom, 0.0f, perimeter));
                    perimeter += width;
                    init_data.add_vertex(Vec4f(right, bottom, 0.0f, perimeter));
                    perimeter += height;
                    init_data.add_vertex(Vec4f(right, top, 0.0f, perimeter));
                    perimeter += width;
                    init_data.add_vertex(Vec4f(left, top, 0.0f, perimeter));
                    perimeter += height;
                    init_data.add_vertex(Vec4f(left, bottom, 0.0f, perimeter));
 
                    // indices
                    init_data.add_line(0, 1);
                    init_data.add_line(1, 2);
                    init_data.add_line(2, 3);
                    init_data.add_line(3, 4);
#if !SLIC3R_OPENGL_ES
                }
                else {
                    init_data.add_vertex(Vec2f(left, bottom));
                    init_data.add_vertex(Vec2f(right, bottom));
                    init_data.add_vertex(Vec2f(right, top));
                    init_data.add_vertex(Vec2f(left, top));
 
                    // indices
                    init_data.add_index(0);
                    init_data.add_index(1);
                    init_data.add_index(2);
                    init_data.add_index(3);
                }
#endif // !SLIC3R_OPENGL_ES
 
                m_rectangle.init_from(std::move(init_data));
            }
 
            shader->set_uniform("view_model_matrix", Transform3d::Identity());
            shader->set_uniform("projection_matrix", Transform3d::Identity());
#if !SLIC3R_OPENGL_ES
            if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
                const std::array<int, 4>& viewport = wxGetApp().plater()->get_camera().get_viewport();
                shader->set_uniform("viewport_size", Vec2d(double(viewport[2]), double(viewport[3])));
                shader->set_uniform("width", 0.25f);
                shader->set_uniform("dash_size", 0.01f);
                shader->set_uniform("gap_size", 0.0075f);
#if !SLIC3R_OPENGL_ES
            }
#endif // !SLIC3R_OPENGL_ES
 
            m_rectangle.set_color(ColorRGBA::ORCA()); // ORCA: use orca color for selection rectangle
            m_rectangle.render();
            shader->stop_using();
        }
 
#if !SLIC3R_OPENGL_ES
        if (!OpenGLManager::get_gl_info().is_core_profile())
            glsafe(::glPopAttrib());
#endif // !SLIC3R_OPENGL_ES
    }

References Slic3r::GUI::GLModel::Geometry::add_index(), Slic3r::GUI::GLModel::Geometry::add_line(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::format, get_bottom(), Slic3r::GUI::GLCanvas3D::get_canvas_size(), Slic3r::GUI::OpenGLManager::get_gl_info(), Slic3r::GUI::Size::get_height(), get_left(), get_right(), get_top(), Slic3r::GUI::Size::get_width(), GL_DEPTH_TEST, GL_ENABLE_BIT, GL_LINE_STIPPLE, glDisable, glEnable, glLineStipple, glLineWidth, glPopAttrib, glPushAttrib, glsafe, Slic3r::GUI::OpenGLManager::GLInfo::is_core_profile(), is_dragging(), Slic3r::GUI::GLModel::Geometry::LineLoop, Slic3r::GUI::GLModel::Geometry::Lines, m_end_corner, m_old_end_corner, m_old_start_corner, m_rectangle, m_start_corner, Slic3r::ColorRGBA::ORCA(), Slic3r::GUI::GLModel::Geometry::P2, Slic3r::GUI::GLModel::Geometry::P4, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Here is the call graph for this function:

start_dragging()

void Slic3r::GUI::GLSelectionRectangle::start_dragging	(	const Vec2d &	mouse_position,
		EState	state )

    {
        if (is_dragging() || (state == Off))
            return;
 
        m_state = state;
        m_start_corner = mouse_position;
        m_end_corner = mouse_position;
    }

References is_dragging(), m_end_corner, m_start_corner, m_state, and Off.

Here is the call graph for this function:

stop_dragging()

void Slic3r::GUI::GLSelectionRectangle::stop_dragging

(

)

    {
        if (is_dragging())
            m_state = Off;
    }

References is_dragging(), m_state, and Off.

Here is the call graph for this function:

Member Data Documentation

m_end_corner

Vec2d Slic3r::GUI::GLSelectionRectangle::m_end_corner { Vec2d::Zero() }

private

{ Vec2d::Zero() };

Referenced by contains(), dragging(), get_bottom(), get_height(), get_left(), get_right(), get_top(), get_width(), render(), and start_dragging().

m_old_end_corner

Vec2d Slic3r::GUI::GLSelectionRectangle::m_old_end_corner { Vec2d::Zero() }

private

{ Vec2d::Zero() };

Referenced by render().

m_old_start_corner

Vec2d Slic3r::GUI::GLSelectionRectangle::m_old_start_corner { Vec2d::Zero() }

private

{ Vec2d::Zero() };

Referenced by render().

m_rectangle

GLModel Slic3r::GUI::GLSelectionRectangle::m_rectangle

private

Referenced by render().

m_start_corner

Vec2d Slic3r::GUI::GLSelectionRectangle::m_start_corner { Vec2d::Zero() }

private

{ Vec2d::Zero() };

Referenced by contains(), get_bottom(), get_height(), get_left(), get_right(), get_top(), get_width(), render(), and start_dragging().

m_state

EState Slic3r::GUI::GLSelectionRectangle::m_state { Off }

private

{ Off };

Referenced by get_state(), is_dragging(), start_dragging(), and stop_dragging().

---

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

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