Slic3r::GUI::GLModel Class Reference

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

Collaboration diagram for Slic3r::GUI::GLModel:

Classes
struct	Geometry
struct	RenderData

Public Member Functions
	GLModel ()=default
virtual	~GLModel ()
size_t	vertices_count () const
size_t	indices_count () const
size_t	vertices_size_floats () const
size_t	vertices_size_bytes () const
size_t	indices_size_bytes () const
const Geometry &	get_geometry () const
void	init_from (Geometry &&data)
void	init_from (const TriangleMesh &mesh)
void	init_from (const indexed_triangle_set &its)
void	init_from (const Polygons &polygons, float z)
bool	init_from_file (const std::string &filename)
void	set_color (const ColorRGBA &color)
const ColorRGBA &	get_color () const
void	reset ()
void	render (GLShaderProgram *shader=nullptr)
void	render (const std::pair< size_t, size_t > &range, GLShaderProgram *shader=nullptr)
void	render_instanced (unsigned int instances_vbo, unsigned int instances_count)
bool	is_initialized () const
bool	is_empty () const
const BoundingBoxf3 &	get_bounding_box () const
const std::string &	get_filename () const
bool	is_render_disabled () const
void	enable_render ()
void	disable_render ()
size_t	cpu_memory_used () const
size_t	gpu_memory_used () const

Private Member Functions
bool	send_to_gpu ()

Private Attributes
RenderData	m_render_data
bool	m_render_disabled { false }
BoundingBoxf3	m_bounding_box
std::string	m_filename

Detailed Description

---

Class Documentation

Slic3r::GUI::GLModel::RenderData

struct Slic3r::GUI::GLModel::RenderData

Collaboration diagram for Slic3r::GUI::GLModel::RenderData:

Class Members
Geometry	geometry
unsigned int	ibo_id { 0 }
size_t	indices_count { 0 }
unsigned int	vao_id { 0 }
unsigned int	vbo_id { 0 }
size_t	vertices_count { 0 }

Constructor & Destructor Documentation

GLModel()

Slic3r::GUI::GLModel::GLModel ( )

default

~GLModel()

virtual Slic3r::GUI::GLModel::~GLModel ( )

inlinevirtual

{ reset(); }

References reset().

Here is the call graph for this function:

Member Function Documentation

cpu_memory_used()

size_t Slic3r::GUI::GLModel::cpu_memory_used ( ) const

inline

                                       {
            size_t ret = 0;
            if (!m_render_data.geometry.vertices.empty())
                ret += vertices_size_bytes();
            if (!m_render_data.geometry.indices.empty())
                ret += indices_size_bytes();
            return ret;
        }

References indices_size_bytes(), m_render_data, and vertices_size_bytes().

Referenced by Slic3r::GLVolume::cpu_memory_used().

Here is the call graph for this function:

Here is the caller graph for this function:

disable_render()

void Slic3r::GUI::GLModel::disable_render ( )

inline

{ m_render_disabled = true; }

References m_render_disabled.

enable_render()

void Slic3r::GUI::GLModel::enable_render ( )

inline

{ m_render_disabled = false; }

References m_render_disabled.

get_bounding_box()

const BoundingBoxf3 & Slic3r::GUI::GLModel::get_bounding_box ( ) const

inline

{ return m_bounding_box; }

References m_bounding_box.

Referenced by Slic3r::GUI::GLCanvas3D::_shadow_casters_signature(), Slic3r::GLVolume::bounding_box(), and Slic3r::GUI::contains().

Here is the caller graph for this function:

get_color()

const ColorRGBA & Slic3r::GUI::GLModel::get_color ( ) const

inline

{ return m_render_data.geometry.color; }

References m_render_data.

get_filename()

const std::string & Slic3r::GUI::GLModel::get_filename ( ) const

inline

{ return m_filename; }

References m_filename.

get_geometry()

const Geometry & Slic3r::GUI::GLModel::get_geometry ( ) const

inline

{ return m_render_data.geometry; }

References m_render_data.

Referenced by Slic3r::GUI::contains(), and Slic3r::GUI::init_raycaster_from_model().

Here is the caller graph for this function:

gpu_memory_used()

size_t Slic3r::GUI::GLModel::gpu_memory_used ( ) const

inline

                                       {
            size_t ret = 0;
            if (m_render_data.geometry.vertices.empty())
                ret += vertices_size_bytes();
            if (m_render_data.geometry.indices.empty())
                ret += indices_size_bytes();
            return ret;
        }

References indices_size_bytes(), m_render_data, and vertices_size_bytes().

Referenced by Slic3r::GLVolume::gpu_memory_used().

Here is the call graph for this function:

Here is the caller graph for this function:

indices_count()

size_t Slic3r::GUI::GLModel::indices_count ( ) const

inline

                                     { return m_render_data.indices_count > 0 ?
            m_render_data.indices_count : m_render_data.geometry.indices_count(); }

References m_render_data.

Referenced by Slic3r::GUI::GLCanvas3D::_shadow_casters_signature(), Slic3r::GUI::GLModel::Geometry::extract_index(), Slic3r::GUI::GLModel::Geometry::get_as_indexed_triangle_set(), indices_size_bytes(), is_initialized(), render(), render_instanced(), send_to_gpu(), and Slic3r::GUI::GLModel::Geometry::set_index().

Here is the caller graph for this function:

indices_size_bytes()

size_t Slic3r::GUI::GLModel::indices_size_bytes ( ) const

inline

{ return indices_count() * Geometry::index_stride_bytes(m_render_data.geometry); }

References Slic3r::GUI::GLModel::Geometry::index_stride_bytes(), indices_count(), and m_render_data.

Referenced by cpu_memory_used(), and gpu_memory_used().

Here is the call graph for this function:

Here is the caller graph for this function:

init_from() [1/4]

void Slic3r::GUI::GLModel::init_from

(

const indexed_triangle_set &

its

)

{
    if (is_initialized()) {
        // call reset() if you want to reuse this model
        assert(false);
        return;
    }
 
    if (its.vertices.empty() || its.indices.empty()){
        assert(false);
        return;
    }
 
    Geometry& data = m_render_data.geometry;
    data.format = { Geometry::EPrimitiveType::Triangles, Geometry::EVertexLayout::P3N3 };
    data.reserve_vertices(3 * its.indices.size());
    data.reserve_indices(3 * its.indices.size());
 
    // CLI thumbnail generation can initialize models without a wx application.
    const bool smooth_normals_enabled = wxApp::GetInstance() != nullptr && wxGetApp().app_config != nullptr &&
                                        wxGetApp().app_config->get_bool(SETTING_OPENGL_PHONG_SMOOTH_NORMALS);
 
    if (smooth_normals_enabled) {
        const std::vector<Vec3f> corner_normals = its_smooth_corner_normals(its, 5.0);
 
        unsigned int vertices_counter = 0;
        for (uint32_t i = 0; i < its.indices.size(); ++i) {
            const stl_triangle_vertex_indices face = its.indices[i];
            for (size_t j = 0; j < 3; ++j)
                data.add_vertex(its.vertices[face[j]], corner_normals[3 * i + j]);
            data.add_triangle(vertices_counter, vertices_counter + 1, vertices_counter + 2);
            vertices_counter += 3;
        }
    } else {
        //Original flat (per-face) normals
        unsigned int vertices_counter = 0;
        for (uint32_t i = 0; i < its.indices.size(); ++i) {
            const stl_triangle_vertex_indices face = its.indices[i];
            const stl_vertex vertex[3] = {its.vertices[face[0]], its.vertices[face[1]], its.vertices[face[2]]};
            const stl_vertex n = face_normal_normalized(vertex);
            for (size_t j = 0; j < 3; ++j)
                data.add_vertex(vertex[j], n);
            data.add_triangle(vertices_counter, vertices_counter + 1, vertices_counter + 2);
            vertices_counter += 3;
        }
    }
 
    // update bounding box
    for (size_t i = 0; i < vertices_count(); ++i) {
        m_bounding_box.merge(data.extract_position_3(i).cast<double>());
    }
}

References Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::extract_position_3(), Slic3r::face_normal_normalized(), Slic3r::GUI::GLModel::Geometry::format, is_initialized(), Slic3r::its_smooth_corner_normals(), m_bounding_box, m_render_data, Slic3r::GUI::GLModel::Geometry::P3N3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), SETTING_OPENGL_PHONG_SMOOTH_NORMALS, Slic3r::GUI::GLModel::Geometry::Triangles, and vertices_count().

Here is the call graph for this function:

init_from() [2/4]

void Slic3r::GUI::GLModel::init_from	(	const Polygons &	polygons,
		float	z )

{
    if (is_initialized()) {
        // call reset() if you want to reuse this model
        assert(false);
        return;
    }
 
    if (polygons.empty()) {
        assert(false);
        return;
    }
 
    Geometry& data = m_render_data.geometry;
    data.format = { Geometry::EPrimitiveType::Lines, Geometry::EVertexLayout::P3 };
 
    size_t segments_count = 0;
    for (const Polygon& polygon : polygons) {
        segments_count += polygon.points.size();
    }
 
    data.reserve_vertices(2 * segments_count);
    data.reserve_indices(2 * segments_count);
 
    // vertices + indices
    unsigned int vertices_counter = 0;
    for (const Polygon& poly : polygons) {
        for (size_t i = 0; i < poly.points.size(); ++i) {
            const Point& p0 = poly.points[i];
            const Point& p1 = (i == poly.points.size() - 1) ? poly.points.front() : poly.points[i + 1];
            data.add_vertex(Vec3f(unscale<float>(p0.x()), unscale<float>(p0.y()), z));
            data.add_vertex(Vec3f(unscale<float>(p1.x()), unscale<float>(p1.y()), z));
            vertices_counter += 2;
            data.add_line(vertices_counter - 2, vertices_counter - 1);
        }
    }
 
    // update bounding box
    for (size_t i = 0; i < vertices_count(); ++i) {
        m_bounding_box.merge(data.extract_position_3(i).cast<double>());
    }
}

References Slic3r::GUI::GLModel::Geometry::add_line(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::extract_position_3(), Slic3r::GUI::GLModel::Geometry::format, is_initialized(), Slic3r::GUI::GLModel::Geometry::Lines, m_bounding_box, m_render_data, Slic3r::GUI::GLModel::Geometry::P3, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::unscale(), and vertices_count().

Here is the call graph for this function:

init_from() [3/4]

void Slic3r::GUI::GLModel::init_from

(

const TriangleMesh &

mesh

)

{
    init_from(mesh.its);
}

References init_from(), and Slic3r::TriangleMesh::its.

Here is the call graph for this function:

init_from() [4/4]

void Slic3r::GUI::GLModel::init_from

(

Geometry &&

data

)

{
    if (is_initialized()) {
        // call reset() if you want to reuse this model
        assert(false);
        return;
    }
 
    if (data.vertices.empty() || data.indices.empty()) {
        assert(false);
        return;
    }
 
    m_render_data.geometry = std::move(data);
 
    // update bounding box
    for (size_t i = 0; i < vertices_count(); ++i) {
        const size_t position_stride = Geometry::position_stride_floats(data.format);
        if (position_stride == 3)
            m_bounding_box.merge(m_render_data.geometry.extract_position_3(i).cast<double>());
        else if (position_stride == 2) {
            const Vec2f position = m_render_data.geometry.extract_position_2(i);
            m_bounding_box.merge(Vec3f(position.x(), position.y(), 0.0f).cast<double>());
        }
    }
}

References is_initialized(), m_bounding_box, m_render_data, Slic3r::GUI::GLModel::Geometry::position_stride_floats(), and vertices_count().

Referenced by Slic3r::GUI::GLCanvas3D::_load_sla_shells(), Slic3r::GUI::GLCanvas3D::_render_sla_slices(), Slic3r::GUI::DesignSketchTool::draw_fill(), Slic3r::GUI::DesignSketchTool::draw_fill_holed(), Slic3r::GUI::DesignSketchTool::draw_quad_strip(), Slic3r::GUI::DesignSketchTool::draw_strokes(), Slic3r::GUI::DesignSketchTool::draw_vertices(), Slic3r::GUI::GLGizmoMeasure::init_circle_glmodel(), Slic3r::GUI::init_exclusion_volume_prism_model(), init_from(), Slic3r::GUI::init_from_angle_arc(), Slic3r::GUI::init_from_circle(), init_from_file(), Slic3r::GUI::init_from_scale(), Slic3r::GUI::init_from_snap_radii(), Slic3r::GUI::init_model_from_expolygons(), Slic3r::GUI::init_model_from_lines(), Slic3r::GUI::init_model_from_lines(), Slic3r::GUI::init_model_from_poly(), Slic3r::GUI::init_model_from_polygons(), Slic3r::GUI::GLGizmoMeasure::init_plane_glmodel(), Slic3r::GLVolumeCollection::load_object_auxiliary(), Slic3r::GLVolumeCollection::load_object_volume(), Slic3r::GLVolumeCollection::load_real_wipe_tower_preview(), Slic3r::GLVolumeCollection::load_wipe_tower_preview(), Slic3r::GUI::MeshClipper::recalculate_triangles(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::DesignSketchTool::render_base_pick(), Slic3r::GUI::GLGizmoBase::render_cross_mark(), Slic3r::GUI::DesignSketchTool::render_datum_gizmo(), Slic3r::GUI::DesignSketchTool::render_datum_planes(), Slic3r::GUI::DesignSketchTool::render_helix_gizmo(), Slic3r::GUI::DesignSketchTool::render_hole_gizmo(), Slic3r::GUI::DesignSketchTool::render_reference_axes(), Slic3r::GUI::DesignSketchTool::render_rib_gizmo(), Slic3r::GUI::render_ribbons(), Slic3r::GUI::GLTexture::render_sub_texture(), and Slic3r::GUI::DesignSketchTool::render_view_helpers().

Here is the call graph for this function:

Here is the caller graph for this function:

init_from_file()

bool Slic3r::GUI::GLModel::init_from_file

(

const std::string &

filename

)

{
    if (!boost::filesystem::exists(filename))
        return false;
 
    if (!boost::algorithm::iends_with(filename, ".stl"))
        return false;
 
    Model model;
    try {
        model = Model::read_from_file(filename);
    }
    catch (std::exception&) {
        return false;
    }
 
    init_from(model.mesh());
 
    m_filename = filename;
 
    return true;
}

References init_from(), m_filename, Slic3r::Model::mesh(), and Slic3r::Model::read_from_file().

Here is the call graph for this function:

is_empty()

bool Slic3r::GUI::GLModel::is_empty ( ) const

inline

{ return m_render_data.geometry.is_empty(); }

References m_render_data.

Referenced by Slic3r::GLVolume::empty().

Here is the caller graph for this function:

is_initialized()

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

inline

{ return vertices_count() > 0 && indices_count() > 0; }

References indices_count(), and vertices_count().

Referenced by Slic3r::GUI::GLCanvas3D::_render_sla_slices(), Slic3r::GUI::GLGizmoMeasure::init_circle_glmodel(), init_from(), init_from(), init_from(), Slic3r::GUI::GLGizmoMeasure::init_plane_glmodel(), Slic3r::GUI::UVEditorCanvas::render(), Slic3r::GUI::PartPlate::render_logo_texture(), Slic3r::GUI::GLGizmoTextureDisplacement::render_paint_overlay(), and Slic3r::GLVolume::simple_render().

Here is the call graph for this function:

Here is the caller graph for this function:

is_render_disabled()

bool Slic3r::GUI::GLModel::is_render_disabled ( ) const

inline

{ return m_render_disabled; }

References m_render_disabled.

render() [1/2]

void Slic3r::GUI::GLModel::render	(	const std::pair< size_t, size_t > &	range,
		GLShaderProgram *	shader = nullptr )

{
    if (m_render_disabled)
        return;
 
    if (range.second == range.first)
        return;
 
    if (shader == nullptr && wxApp::GetInstance() != nullptr)
        shader = wxGetApp().get_current_shader();
 
    if (shader == nullptr)
        return;
 
    // sends data to gpu if not done yet
    if (m_render_data.vbo_id == 0 || m_render_data.ibo_id == 0) {
        if (m_render_data.geometry.vertices_count() > 0 && m_render_data.geometry.indices_count() > 0 && !send_to_gpu())
            return;
    }
 
    const Geometry& data = m_render_data.geometry;
 
    const GLenum mode = get_primitive_mode(data.format);
    const GLenum index_type = get_index_type(data);
 
    const size_t vertex_stride_bytes = Geometry::vertex_stride_bytes(data.format);
    const bool position = Geometry::has_position(data.format);
    const bool normal = Geometry::has_normal(data.format);
    const bool tex_coord = Geometry::has_tex_coord(data.format);
 
#if !SLIC3R_OPENGL_ES
    if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
        glsafe(::glBindVertexArray(m_render_data.vao_id));
#if !SLIC3R_OPENGL_ES
    }
#endif // !SLIC3R_OPENGL_ES
    // the following binding is needed to set the vertex attributes
    glsafe(::glBindBuffer(GL_ARRAY_BUFFER, m_render_data.vbo_id));
 
    int position_id = -1;
    int normal_id = -1;
    int tex_coord_id = -1;
 
    if (position) {
        position_id = shader->get_attrib_location("v_position");
        if (position_id != -1) {
            glsafe(::glVertexAttribPointer(position_id, Geometry::position_stride_floats(data.format), GL_FLOAT, GL_FALSE, vertex_stride_bytes, (const void*)Geometry::position_offset_bytes(data.format)));
            glsafe(::glEnableVertexAttribArray(position_id));
        }
    }
    if (normal) {
        normal_id = shader->get_attrib_location("v_normal");
        if (normal_id != -1) {
            glsafe(::glVertexAttribPointer(normal_id, Geometry::normal_stride_floats(data.format), GL_FLOAT, GL_FALSE, vertex_stride_bytes, (const void*)Geometry::normal_offset_bytes(data.format)));
            glsafe(::glEnableVertexAttribArray(normal_id));
        }
    }
    if (tex_coord) {
        tex_coord_id = shader->get_attrib_location("v_tex_coord");
        if (tex_coord_id != -1) {
            glsafe(::glVertexAttribPointer(tex_coord_id, Geometry::tex_coord_stride_floats(data.format), GL_FLOAT, GL_FALSE, vertex_stride_bytes, (const void*)Geometry::tex_coord_offset_bytes(data.format)));
            glsafe(::glEnableVertexAttribArray(tex_coord_id));
        }
    }
 
    shader->set_uniform("uniform_color", data.color);
 
    glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_render_data.ibo_id));
    glsafe(::glDrawElements(mode, range.second - range.first, index_type, (const void*)(range.first * Geometry::index_stride_bytes(data))));
    glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
 
    if (tex_coord_id != -1)
        glsafe(::glDisableVertexAttribArray(tex_coord_id));
    if (normal_id != -1)
        glsafe(::glDisableVertexAttribArray(normal_id));
    if (position_id != -1)
        glsafe(::glDisableVertexAttribArray(position_id));
 
    glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
#if !SLIC3R_OPENGL_ES
    if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
        glsafe(::glBindVertexArray(0));
#if !SLIC3R_OPENGL_ES
    }
#endif // !SLIC3R_OPENGL_ES
}

References Slic3r::GUI::GLModel::Geometry::color, Slic3r::GUI::GLModel::Geometry::format, Slic3r::GLShaderProgram::get_attrib_location(), Slic3r::GUI::OpenGLManager::get_gl_info(), Slic3r::GUI::get_index_type(), Slic3r::GUI::get_primitive_mode(), GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_FALSE, GL_FLOAT, glBindBuffer, glBindVertexArray, glDisableVertexAttribArray, glDrawElements, glEnableVertexAttribArray, glsafe, glVertexAttribPointer, Slic3r::GUI::GLModel::Geometry::has_normal(), Slic3r::GUI::GLModel::Geometry::has_position(), Slic3r::GUI::GLModel::Geometry::has_tex_coord(), Slic3r::GUI::GLModel::Geometry::index_stride_bytes(), m_render_data, m_render_disabled, Slic3r::normal(), Slic3r::GUI::GLModel::Geometry::normal_offset_bytes(), Slic3r::GUI::GLModel::Geometry::normal_stride_floats(), Slic3r::GUI::GLModel::Geometry::position_offset_bytes(), Slic3r::GUI::GLModel::Geometry::position_stride_floats(), Slic3r::range(), send_to_gpu(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GUI::GLModel::Geometry::tex_coord_offset_bytes(), Slic3r::GUI::GLModel::Geometry::tex_coord_stride_floats(), and Slic3r::GUI::GLModel::Geometry::vertex_stride_bytes().

Here is the call graph for this function:

render() [2/2]

void Slic3r::GUI::GLModel::render

(

GLShaderProgram *

shader = nullptr

)

{
    render(std::make_pair<size_t, size_t>(0, indices_count()), shader);
}

References indices_count(), and render().

Referenced by Slic3r::GUI::GLCanvas3D::_render_shadows(), Slic3r::GUI::GLCanvas3D::_render_sla_slices(), Slic3r::GUI::DesignSketchTool::draw_fill(), Slic3r::GUI::DesignSketchTool::draw_fill_holed(), Slic3r::GUI::DesignSketchTool::draw_quad_strip(), Slic3r::GUI::DesignSketchTool::draw_strokes(), Slic3r::GUI::DesignSketchTool::draw_vertices(), render(), Slic3r::GUI::SceneCache::render(), Slic3r::GUI::UVEditorCanvas::render(), Slic3r::GUI::DesignSketchTool::render_base_pick(), Slic3r::GUI::MeshClipper::render_contour(), Slic3r::GUI::GLGizmoBase::render_cross_mark(), Slic3r::GUI::MeshClipper::render_cut(), Slic3r::GUI::DesignSketchTool::render_datum_gizmo(), Slic3r::GUI::DesignSketchTool::render_datum_planes(), Slic3r::GUI::DesignSketchTool::render_helix_gizmo(), Slic3r::GUI::DesignSketchTool::render_hole_gizmo(), Slic3r::GUI::PartPlate::render_icon_texture(), Slic3r::GUI::GLGizmoCut3D::render_line(), Slic3r::GUI::PartPlate::render_logo_texture(), Slic3r::GUI::GLGizmoCut3D::render_model(), Slic3r::GUI::GLGizmoTextureDisplacement::render_paint_overlay(), Slic3r::GUI::DesignSketchTool::render_reference_axes(), Slic3r::GUI::DesignSketchTool::render_rib_gizmo(), Slic3r::GUI::render_ribbons(), Slic3r::GUI::GLTexture::render_sub_texture(), Slic3r::GUI::DesignSketchTool::render_view_helpers(), and Slic3r::GLVolume::simple_render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_instanced()

void Slic3r::GUI::GLModel::render_instanced	(	unsigned int	instances_vbo,
		unsigned int	instances_count )

{
    if (instances_vbo == 0 || instances_count == 0)
        return;
 
    GLShaderProgram* shader = wxGetApp().get_current_shader();
    if (shader == nullptr || !boost::algorithm::iends_with(shader->get_name(), "_instanced"))
        return;
 
    // vertex attributes
    const GLint position_id = shader->get_attrib_location("v_position");
    const GLint normal_id   = shader->get_attrib_location("v_normal");
    if (position_id == -1 || normal_id == -1)
        return;
 
    // instance attributes
    const GLint offset_id = shader->get_attrib_location("i_offset");
    const GLint scales_id = shader->get_attrib_location("i_scales");
    if (offset_id == -1 || scales_id == -1)
        return;
 
    if (m_render_data.vbo_id == 0 || m_render_data.ibo_id == 0) {
        if (!send_to_gpu())
            return;
    }
 
#if !SLIC3R_OPENGL_ES
    if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
        glsafe(::glBindVertexArray(m_render_data.vao_id));
#if !SLIC3R_OPENGL_ES
    }
#endif // !SLIC3R_OPENGL_ES
 
    glsafe(::glBindBuffer(GL_ARRAY_BUFFER, instances_vbo));
    const size_t instance_stride = 5 * sizeof(float);
    glsafe(::glVertexAttribPointer(offset_id, 3, GL_FLOAT, GL_FALSE, instance_stride, (const void*)0));
    glsafe(::glEnableVertexAttribArray(offset_id));
    glsafe(::glVertexAttribDivisor(offset_id, 1));
 
    glsafe(::glVertexAttribPointer(scales_id, 2, GL_FLOAT, GL_FALSE, instance_stride, (const void*)(3 * sizeof(float))));
    glsafe(::glEnableVertexAttribArray(scales_id));
    glsafe(::glVertexAttribDivisor(scales_id, 1));
 
    const Geometry& data = m_render_data.geometry;
 
    const GLenum mode = get_primitive_mode(data.format);
    const GLenum index_type = get_index_type(data);
 
    const size_t vertex_stride_bytes = Geometry::vertex_stride_bytes(data.format);
    const bool position = Geometry::has_position(data.format);
    const bool normal   = Geometry::has_normal(data.format);
 
    glsafe(::glBindBuffer(GL_ARRAY_BUFFER, m_render_data.vbo_id));
 
    if (position) {
        glsafe(::glVertexAttribPointer(position_id, Geometry::position_stride_floats(data.format), GL_FLOAT, GL_FALSE, vertex_stride_bytes, (const void*)Geometry::position_offset_bytes(data.format)));
        glsafe(::glEnableVertexAttribArray(position_id));
    }
 
    if (normal) {
        glsafe(::glVertexAttribPointer(normal_id, Geometry::normal_stride_floats(data.format), GL_FLOAT, GL_FALSE, vertex_stride_bytes, (const void*)Geometry::normal_offset_bytes(data.format)));
        glsafe(::glEnableVertexAttribArray(normal_id));
    }
 
    shader->set_uniform("uniform_color", data.color);
 
    glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_render_data.ibo_id));
    glsafe(::glDrawElementsInstanced(mode, indices_count(), index_type, (const void*)0, instances_count));
    glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
 
    if (normal)
        glsafe(::glDisableVertexAttribArray(normal_id));
    if (position)
        glsafe(::glDisableVertexAttribArray(position_id));
 
    glsafe(::glDisableVertexAttribArray(scales_id));
    glsafe(::glDisableVertexAttribArray(offset_id));
 
    glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
#if !SLIC3R_OPENGL_ES
    if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
        glsafe(::glBindVertexArray(0));
#if !SLIC3R_OPENGL_ES
    }
#endif // !SLIC3R_OPENGL_ES
}

References Slic3r::GUI::GLModel::Geometry::color, Slic3r::GUI::GLModel::Geometry::format, Slic3r::GLShaderProgram::get_attrib_location(), Slic3r::GUI::OpenGLManager::get_gl_info(), Slic3r::GUI::get_index_type(), Slic3r::GLShaderProgram::get_name(), Slic3r::GUI::get_primitive_mode(), GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_FALSE, GL_FLOAT, glBindBuffer, glBindVertexArray, glDisableVertexAttribArray, glDrawElementsInstanced, glEnableVertexAttribArray, glsafe, glVertexAttribDivisor, glVertexAttribPointer, Slic3r::GUI::GLModel::Geometry::has_normal(), Slic3r::GUI::GLModel::Geometry::has_position(), indices_count(), m_render_data, Slic3r::normal(), Slic3r::GUI::GLModel::Geometry::normal_offset_bytes(), Slic3r::GUI::GLModel::Geometry::normal_stride_floats(), Slic3r::GUI::GLModel::Geometry::position_offset_bytes(), Slic3r::GUI::GLModel::Geometry::position_stride_floats(), send_to_gpu(), Slic3r::GLShaderProgram::set_uniform(), and Slic3r::GUI::GLModel::Geometry::vertex_stride_bytes().

Here is the call graph for this function:

reset()

void Slic3r::GUI::GLModel::reset

(

)

{
    // release gpu memory
    if (m_render_data.ibo_id > 0) {
        glsafe(::glDeleteBuffers(1, &m_render_data.ibo_id));
        m_render_data.ibo_id = 0;
    }
    if (m_render_data.vbo_id > 0) {
        glsafe(::glDeleteBuffers(1, &m_render_data.vbo_id));
        m_render_data.vbo_id = 0;
    }
#if !SLIC3R_OPENGL_ES
    if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
        if (m_render_data.vao_id > 0) {
            glsafe(::glDeleteVertexArrays(1, &m_render_data.vao_id));
            m_render_data.vao_id = 0;
        }
#if !SLIC3R_OPENGL_ES
    }
#endif // !SLIC3R_OPENGL_ES
 
    m_render_data.vertices_count = 0;
    m_render_data.indices_count  = 0;
    m_render_data.geometry.vertices = std::vector<float>();
    m_render_data.geometry.indices  = std::vector<unsigned int>();
    m_bounding_box = BoundingBoxf3();
    m_filename = std::string();
}

References Slic3r::GUI::OpenGLManager::get_gl_info(), glDeleteBuffers, glDeleteVertexArrays, glsafe, m_bounding_box, m_filename, and m_render_data.

Referenced by ~GLModel(), Slic3r::GUI::PartPlate::calc_triangles_from_polygon(), Slic3r::GUI::PartPlate::calc_vertex_for_imex_warn_badge(), Slic3r::GUI::PartPlate::calc_vertex_for_number(), Slic3r::GUI::DesignSketchTool::draw_fill(), Slic3r::GUI::DesignSketchTool::draw_fill_holed(), Slic3r::GUI::DesignSketchTool::draw_quad_strip(), Slic3r::GUI::DesignSketchTool::draw_strokes(), Slic3r::GUI::DesignSketchTool::draw_vertices(), Slic3r::GUI::init_exclusion_volume_prism_model(), Slic3r::GUI::init_from_angle_arc(), Slic3r::GUI::init_model_from_expolygons(), Slic3r::GUI::init_model_from_polygons(), Slic3r::GUI::GLCanvas3D::reload_scene(), and Slic3r::GUI::render_ribbons().

Here is the call graph for this function:

Here is the caller graph for this function:

send_to_gpu()

bool Slic3r::GUI::GLModel::send_to_gpu ( )

private

{
    if (m_render_data.vbo_id > 0 || m_render_data.ibo_id > 0) {
        assert(false);
        return false;
    }
 
    Geometry& data = m_render_data.geometry;
    if (data.vertices.empty() || data.indices.empty()) {
        assert(false);
        return false;
    }
 
#if !SLIC3R_OPENGL_ES
    if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
        glsafe(::glGenVertexArrays(1, &m_render_data.vao_id));
        glsafe(::glBindVertexArray(m_render_data.vao_id));
#if !SLIC3R_OPENGL_ES
    }
#endif // !SLIC3R_OPENGL_ES
 
    // vertices
    glsafe(::glGenBuffers(1, &m_render_data.vbo_id));
    glsafe(::glBindBuffer(GL_ARRAY_BUFFER, m_render_data.vbo_id));
    glsafe(::glBufferData(GL_ARRAY_BUFFER, data.vertices_size_bytes(), data.vertices.data(), GL_STATIC_DRAW));
    glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
    m_render_data.vertices_count = vertices_count();
    data.vertices = std::vector<float>();
 
    // indices
    glsafe(::glGenBuffers(1, &m_render_data.ibo_id));
    glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_render_data.ibo_id));
    const size_t indices_count = data.indices.size();
    if (m_render_data.vertices_count <= 256) {
        // convert indices to unsigned char to save gpu memory
        std::vector<unsigned char> reduced_indices(indices_count);
        for (size_t i = 0; i < indices_count; ++i) {
            reduced_indices[i] = (unsigned char)data.indices[i];
        }
        data.index_type = Geometry::EIndexType::UBYTE;
        glsafe(::glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices_count * sizeof(unsigned char), reduced_indices.data(), GL_STATIC_DRAW));
        glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
    }
    else if (m_render_data.vertices_count <= 65536) {
        // convert indices to unsigned short to save gpu memory
        std::vector<unsigned short> reduced_indices(indices_count);
        for (size_t i = 0; i < data.indices.size(); ++i) {
            reduced_indices[i] = (unsigned short)data.indices[i];
        }
        data.index_type = Geometry::EIndexType::USHORT;
        glsafe(::glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices_count * sizeof(unsigned short), reduced_indices.data(), GL_STATIC_DRAW));
        glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
    }
    else {
        data.index_type = Geometry::EIndexType::UINT;
        glsafe(::glBufferData(GL_ELEMENT_ARRAY_BUFFER, data.indices_size_bytes(), data.indices.data(), GL_STATIC_DRAW));
        glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
    }
    m_render_data.indices_count = indices_count;
    data.indices = std::vector<unsigned int>();
 
#if !SLIC3R_OPENGL_ES
    if (OpenGLManager::get_gl_info().is_core_profile()) {
#endif // !SLIC3R_OPENGL_ES
        glsafe(::glBindVertexArray(0));
#if !SLIC3R_OPENGL_ES
    }
#endif // !SLIC3R_OPENGL_ES
 
    return true;
}

References Slic3r::GUI::OpenGLManager::get_gl_info(), GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_STATIC_DRAW, glBindBuffer, glBindVertexArray, glBufferData, glGenBuffers, glGenVertexArrays, glsafe, Slic3r::GUI::GLModel::Geometry::index_type, Slic3r::GUI::GLModel::Geometry::indices, indices_count(), Slic3r::GUI::GLModel::Geometry::indices_size_bytes(), m_render_data, Slic3r::GUI::GLModel::Geometry::UBYTE, Slic3r::GUI::GLModel::Geometry::UINT, Slic3r::GUI::GLModel::Geometry::USHORT, Slic3r::GUI::GLModel::Geometry::vertices, vertices_count(), and Slic3r::GUI::GLModel::Geometry::vertices_size_bytes().

Referenced by render(), and render_instanced().

Here is the call graph for this function:

Here is the caller graph for this function:

set_color()

void Slic3r::GUI::GLModel::set_color ( const ColorRGBA & color )

inline

{ m_render_data.geometry.color = color; }

References m_render_data.

Referenced by Slic3r::GUI::GLCanvas3D::_render_below_plate_volumes(), Slic3r::GUI::DesignSketchTool::draw_fill(), Slic3r::GUI::DesignSketchTool::draw_fill_holed(), Slic3r::GUI::DesignSketchTool::draw_quad_strip(), Slic3r::GUI::DesignSketchTool::draw_strokes(), Slic3r::GUI::DesignSketchTool::draw_vertices(), Slic3r::GUI::init_from_circle(), Slic3r::GUI::init_from_scale(), Slic3r::GUI::init_from_snap_radii(), Slic3r::GLVolumeCollection::load_object_auxiliary(), Slic3r::GUI::UVEditorCanvas::render(), Slic3r::GUI::DesignSketchTool::render_base_pick(), Slic3r::GUI::MeshClipper::render_contour(), Slic3r::GUI::MeshClipper::render_cut(), Slic3r::GUI::DesignSketchTool::render_datum_gizmo(), Slic3r::GUI::DesignSketchTool::render_datum_planes(), Slic3r::GUI::DesignSketchTool::render_helix_gizmo(), Slic3r::GUI::DesignSketchTool::render_hole_gizmo(), Slic3r::GUI::GLGizmoCut3D::render_line(), Slic3r::GUI::GLGizmoCut3D::render_model(), Slic3r::GUI::DesignSketchTool::render_reference_axes(), Slic3r::GUI::DesignSketchTool::render_rib_gizmo(), Slic3r::GUI::render_ribbons(), Slic3r::GUI::DesignSketchTool::render_view_helpers(), and Slic3r::GLVolume::simple_render().

Here is the caller graph for this function:

vertices_count()

size_t Slic3r::GUI::GLModel::vertices_count ( ) const

inline

                                      { return m_render_data.vertices_count > 0 ?
            m_render_data.vertices_count : m_render_data.geometry.vertices_count(); }

References m_render_data.

Referenced by Slic3r::GUI::GLCanvas3D::_shadow_casters_signature(), Slic3r::GUI::GLModel::Geometry::extract_normal_3(), Slic3r::GUI::GLModel::Geometry::extract_position_2(), Slic3r::GUI::GLModel::Geometry::extract_position_3(), Slic3r::GUI::GLModel::Geometry::extract_tex_coord_2(), Slic3r::GUI::GLModel::Geometry::get_as_indexed_triangle_set(), init_from(), init_from(), init_from(), is_initialized(), Slic3r::GUI::GLModel::Geometry::remove_vertex(), send_to_gpu(), Slic3r::GUI::GLModel::Geometry::set_vertex(), and vertices_size_floats().

Here is the caller graph for this function:

vertices_size_bytes()

size_t Slic3r::GUI::GLModel::vertices_size_bytes ( ) const

inline

{ return vertices_size_floats() * sizeof(float); }

References vertices_size_floats().

Referenced by cpu_memory_used(), and gpu_memory_used().

Here is the call graph for this function:

Here is the caller graph for this function:

vertices_size_floats()

size_t Slic3r::GUI::GLModel::vertices_size_floats ( ) const

inline

{ return vertices_count() * Geometry::vertex_stride_floats(m_render_data.geometry.format); }

References m_render_data, Slic3r::GUI::GLModel::Geometry::vertex_stride_floats(), and vertices_count().

Referenced by vertices_size_bytes().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_bounding_box

BoundingBoxf3 Slic3r::GUI::GLModel::m_bounding_box

private

Referenced by get_bounding_box(), init_from(), init_from(), init_from(), and reset().

m_filename

std::string Slic3r::GUI::GLModel::m_filename

private

Referenced by get_filename(), init_from_file(), and reset().

m_render_data

RenderData Slic3r::GUI::GLModel::m_render_data

private

Referenced by cpu_memory_used(), get_color(), get_geometry(), gpu_memory_used(), indices_count(), indices_size_bytes(), init_from(), init_from(), init_from(), is_empty(), render(), render_instanced(), reset(), send_to_gpu(), set_color(), vertices_count(), and vertices_size_floats().

m_render_disabled

bool Slic3r::GUI::GLModel::m_render_disabled { false }

private

{ false };

Referenced by disable_render(), enable_render(), is_render_disabled(), and render().

---

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

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