Slic3r::GUI::GLCanvas3D::LayersEditing Class Reference

Collaboration diagram for Slic3r::GUI::GLCanvas3D::LayersEditing:

Classes
struct	LayersTexture
struct	Profile

Public Types
enum	EState : unsigned char { Unknown , Editing , Completed , Num_States }

Public Member Functions
void	set_shrinkage_compensation (const Vec3d &shrinkage_compensation)
	LayersEditing ()=default
	~LayersEditing ()
void	init ()
void	set_config (const DynamicPrintConfig *config)
void	select_object (const Model &model, int object_id)
bool	is_allowed () const
bool	is_enabled () const
void	set_enabled (bool enabled)
void	render_variable_layer_height_dialog (GLCanvas3D &canvas)
void	render_overlay (GLCanvas3D &canvas)
void	render_volumes (const GLCanvas3D &canvas, const GLVolumeCollection &volumes)
void	adjust_layer_height_profile ()
void	accept_changes (GLCanvas3D &canvas)
void	reset_layer_height_profile (GLCanvas3D &canvas)
void	adaptive_layer_height_profile (GLCanvas3D &canvas, float quality_factor)
void	smooth_layer_height_profile (GLCanvas3D &canvas, const HeightProfileSmoothingParams &smoothing_params)
float	object_max_z () const
std::string	get_tooltip (const GLCanvas3D &canvas) const

Static Public Member Functions
static float	get_cursor_z_relative (const GLCanvas3D &canvas)
static bool	bar_rect_contains (const GLCanvas3D &canvas, float x, float y)
static Rect	get_bar_rect_screen (const GLCanvas3D &canvas)
static float	get_overlay_window_width ()

Public Attributes
EState	state { Unknown }
float	band_width { 2.0f }
float	strength { 0.005f }
int	last_object_id { -1 }
float	last_z { 0.0f }
LayerHeightEditActionType	last_action { LAYER_HEIGHT_EDIT_ACTION_INCREASE }
Profile	m_profile

Static Public Attributes
static const float	THICKNESS_BAR_WIDTH = 70.0f

Private Member Functions
bool	is_initialized () const
void	generate_layer_height_texture ()
void	render_active_object_annotations (const GLCanvas3D &canvas)
void	render_profile (const GLCanvas3D &canvas)
void	update_slicing_parameters ()

Static Private Member Functions
static float	thickness_bar_width (const GLCanvas3D &canvas)

Private Attributes
bool	m_enabled { false }
unsigned int	m_z_texture_id { 0 }
const DynamicPrintConfig *	m_config { nullptr }
const ModelObject *	m_model_object { nullptr }
float	m_object_max_z { 0.0f }
SlicingParameters *	m_slicing_parameters { nullptr }
std::vector< double >	m_layer_height_profile
Vec3d	m_shrinkage_compensation { Vec3d::Ones() }
float	m_adaptive_quality { 0.5f }
HeightProfileSmoothingParams	m_smooth_params
LayersTexture	m_layers_texture

Static Private Attributes
static float	s_overlay_window_width

Detailed Description

---

Class Documentation

Slic3r::GUI::GLCanvas3D::LayersEditing::LayersTexture

struct Slic3r::GUI::GLCanvas3D::LayersEditing::LayersTexture

Collaboration diagram for Slic3r::GUI::GLCanvas3D::LayersEditing::LayersTexture:

Class Members
size_t	cells { 0 }
vector< char >	data
size_t	height { 0 }
size_t	levels { 0 }
bool	valid { false }
size_t	width { 0 }

Slic3r::GUI::GLCanvas3D::LayersEditing::Profile

struct Slic3r::GUI::GLCanvas3D::LayersEditing::Profile

Collaboration diagram for Slic3r::GUI::GLCanvas3D::LayersEditing::Profile:

Class Members
GLModel	background
GLModel	baseline
float	old_canvas_width { 0.0f }
vector< double >	old_layer_height_profile
GLModel	profile

Member Enumeration Documentation

EState

enum Slic3r::GUI::GLCanvas3D::LayersEditing::EState : unsigned char

Enumerator
Unknown
Editing
Completed
Num_States

        {
            Unknown,
            Editing,
            Completed,
            Num_States
        };

Constructor & Destructor Documentation

LayersEditing()

Slic3r::GUI::GLCanvas3D::LayersEditing::LayersEditing ( )

default

~LayersEditing()

Slic3r::GUI::GLCanvas3D::LayersEditing::~LayersEditing

(

)

{
    if (m_z_texture_id != 0) {
        glsafe(::glDeleteTextures(1, &m_z_texture_id));
        m_z_texture_id = 0;
    }
    delete m_slicing_parameters;
}

References ~LayersEditing(), glDeleteTextures, glsafe, m_slicing_parameters, and m_z_texture_id.

Referenced by ~LayersEditing().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

accept_changes()

void Slic3r::GUI::GLCanvas3D::LayersEditing::accept_changes

(

GLCanvas3D &

canvas

)

{
    if (last_object_id >= 0) {
        wxGetApp().plater()->take_snapshot("Variable layer height - Manual edit");
        const_cast<ModelObject*>(m_model_object)->layer_height_profile.set(m_layer_height_profile);
        canvas.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
        wxGetApp().obj_list()->update_info_items(last_object_id);
    }
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), accept_changes(), last_object_id, m_layer_height_profile, m_model_object, and Slic3r::GUI::GLCanvas3D::post_event().

Referenced by accept_changes().

Here is the call graph for this function:

Here is the caller graph for this function:

adaptive_layer_height_profile()

void Slic3r::GUI::GLCanvas3D::LayersEditing::adaptive_layer_height_profile	(	GLCanvas3D &	canvas,
		float	quality_factor )

{
    this->update_slicing_parameters();
    m_layer_height_profile = layer_height_profile_adaptive(*m_slicing_parameters, *m_model_object, quality_factor);
    const_cast<ModelObject*>(m_model_object)->layer_height_profile.set(m_layer_height_profile);
    m_layers_texture.valid = false;
    canvas.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
    wxGetApp().obj_list()->update_info_items(last_object_id);
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), adaptive_layer_height_profile(), last_object_id, Slic3r::layer_height_profile_adaptive(), m_layer_height_profile, m_layers_texture, m_model_object, m_slicing_parameters, Slic3r::GUI::GLCanvas3D::post_event(), and update_slicing_parameters().

Referenced by adaptive_layer_height_profile().

Here is the call graph for this function:

Here is the caller graph for this function:

adjust_layer_height_profile()

void Slic3r::GUI::GLCanvas3D::LayersEditing::adjust_layer_height_profile

(

)

{
    this->update_slicing_parameters();
    PrintObject::update_layer_height_profile(*m_model_object, *m_slicing_parameters, m_layer_height_profile);
    Slic3r::adjust_layer_height_profile(*m_model_object, *m_slicing_parameters, m_layer_height_profile, this->last_z, this->strength, this->band_width, this->last_action);
    m_layers_texture.valid = false;
}

References Slic3r::adjust_layer_height_profile(), adjust_layer_height_profile(), band_width, last_action, last_z, m_layer_height_profile, m_layers_texture, m_model_object, m_slicing_parameters, strength, Slic3r::PrintObject::update_layer_height_profile(), and update_slicing_parameters().

Referenced by adjust_layer_height_profile().

Here is the call graph for this function:

Here is the caller graph for this function:

bar_rect_contains()

bool Slic3r::GUI::GLCanvas3D::LayersEditing::bar_rect_contains ( const GLCanvas3D & canvas, float x, float y )

static

{
    const Rect& rect = get_bar_rect_screen(canvas);
    return rect.get_left() <= x && x <= rect.get_right() && rect.get_top() <= y && y <= rect.get_bottom();
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), bar_rect_contains(), get_bar_rect_screen(), Slic3r::GUI::Rect::get_bottom(), Slic3r::GUI::Rect::get_left(), Slic3r::GUI::Rect::get_right(), and Slic3r::GUI::Rect::get_top().

Referenced by bar_rect_contains().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_layer_height_texture()

void Slic3r::GUI::GLCanvas3D::LayersEditing::generate_layer_height_texture ( )

private

{
    this->update_slicing_parameters();
    // Always try to update the layer height profile.
    bool update = !m_layers_texture.valid;
    if (PrintObject::update_layer_height_profile(*m_model_object, *m_slicing_parameters, m_layer_height_profile)) {
        // Initialized to the default value.
        update = true;
    }
    // Update if the layer height profile was changed, or when the texture is not valid.
    if (!update && !m_layers_texture.data.empty() && m_layers_texture.cells > 0)
        // Texture is valid, don't update.
        return;
 
    if (m_layers_texture.data.empty()) {
        m_layers_texture.width = 1024;
        m_layers_texture.height = 1024;
        m_layers_texture.levels = 2;
        m_layers_texture.data.assign(m_layers_texture.width * m_layers_texture.height * 5, 0);
    }
 
    bool level_of_detail_2nd_level = true;
    m_layers_texture.cells = Slic3r::generate_layer_height_texture(
        *m_slicing_parameters,
        Slic3r::generate_object_layers(*m_slicing_parameters, m_layer_height_profile, false),
        m_layers_texture.data.data(), m_layers_texture.height, m_layers_texture.width, level_of_detail_2nd_level);
    m_layers_texture.valid = true;
}

References Slic3r::generate_layer_height_texture(), generate_layer_height_texture(), Slic3r::generate_object_layers(), m_layer_height_profile, m_layers_texture, m_model_object, m_slicing_parameters, Slic3r::PrintObject::update_layer_height_profile(), and update_slicing_parameters().

Referenced by generate_layer_height_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

get_bar_rect_screen()

Rect Slic3r::GUI::GLCanvas3D::LayersEditing::get_bar_rect_screen ( const GLCanvas3D & canvas )

static

{
    const Size& cnv_size = canvas.get_canvas_size();
    float w = (float)cnv_size.get_width();
    float h = (float)cnv_size.get_height();
 
    return { w - thickness_bar_width(canvas), 0.0f, w, h };
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), get_bar_rect_screen(), Slic3r::GUI::GLCanvas3D::get_canvas_size(), Slic3r::GUI::Size::get_height(), Slic3r::GUI::Size::get_width(), and thickness_bar_width().

Referenced by Slic3r::GUI::GLCanvas3D::_perform_layer_editing_action(), bar_rect_contains(), get_bar_rect_screen(), and get_cursor_z_relative().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cursor_z_relative()

float Slic3r::GUI::GLCanvas3D::LayersEditing::get_cursor_z_relative ( const GLCanvas3D & canvas )

static

{
    const Vec2d mouse_pos = canvas.get_local_mouse_position();
    const Rect& rect = get_bar_rect_screen(canvas);
    float x = (float)mouse_pos.x();
    float y = (float)mouse_pos.y();
    float t = rect.get_top();
    float b = rect.get_bottom();
 
    return (rect.get_left() <= x && x <= rect.get_right() && t <= y && y <= b) ?
        // Inside the bar.
        (b - y - 1.0f) / (b - t - 1.0f) :
        // Outside the bar.
        -1000.0f;
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), get_bar_rect_screen(), Slic3r::GUI::Rect::get_bottom(), get_cursor_z_relative(), Slic3r::GUI::Rect::get_left(), Slic3r::GUI::GLCanvas3D::get_local_mouse_position(), Slic3r::GUI::Rect::get_right(), and Slic3r::GUI::Rect::get_top().

Referenced by get_cursor_z_relative(), get_tooltip(), render_active_object_annotations(), and render_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

get_overlay_window_width()

float Slic3r::GUI::GLCanvas3D::LayersEditing::get_overlay_window_width ( )

inlinestatic

{ return LayersEditing::s_overlay_window_width; }

References s_overlay_window_width.

get_tooltip()

std::string Slic3r::GUI::GLCanvas3D::LayersEditing::get_tooltip

(

const GLCanvas3D &

canvas

)

const

{
    std::string ret;
    if (m_enabled && m_layer_height_profile.size() >= 4) {
        float z = get_cursor_z_relative(canvas);
        if (z != -1000.0f) {
            z *= m_object_max_z;
 
            float h = 0.0f;
            for (size_t i = m_layer_height_profile.size() - 2; i >= 2; i -= 2) {
                const float zi = static_cast<float>(m_layer_height_profile[i]);
                const float zi_1 = static_cast<float>(m_layer_height_profile[i - 2]);
                if (zi_1 <= z && z <= zi) {
                    float dz = zi - zi_1;
                    h = (dz != 0.0f) ? static_cast<float>(lerp(m_layer_height_profile[i - 1], m_layer_height_profile[i + 1], (z - zi_1) / dz)) :
                        static_cast<float>(m_layer_height_profile[i + 1]);
                    break;
                }
            }
            if (h > 0.0f)
                ret = wxString::Format("%.3f",h).ToStdString();
        }
    }
    return ret;
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), get_cursor_z_relative(), get_tooltip(), Slic3r::lerp(), m_enabled, m_layer_height_profile, and m_object_max_z.

Referenced by get_tooltip().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

void Slic3r::GUI::GLCanvas3D::LayersEditing::init

(

)

{
    glsafe(::glGenTextures(1, (GLuint*)&m_z_texture_id));
    glsafe(::glBindTexture(GL_TEXTURE_2D, m_z_texture_id));
    if (!OpenGLManager::get_gl_info().is_core_profile() || !OpenGLManager::get_gl_info().is_mesa()) {
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
    }
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1));
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
}

References Slic3r::GUI::OpenGLManager::get_gl_info(), GL_CLAMP_TO_EDGE, GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_MIN_FILTER, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, glBindTexture, glGenTextures, glsafe, glTexParameteri, init(), and m_z_texture_id.

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

is_allowed()

bool Slic3r::GUI::GLCanvas3D::LayersEditing::is_allowed

(

)

const

{
    return wxGetApp().get_shader("variable_layer_height") != nullptr && m_z_texture_id > 0;
}

References is_allowed(), and m_z_texture_id.

Referenced by is_allowed(), render_volumes(), and set_enabled().

Here is the call graph for this function:

Here is the caller graph for this function:

is_enabled()

bool Slic3r::GUI::GLCanvas3D::LayersEditing::is_enabled ( ) const

inline

{ return m_enabled; }

References m_enabled.

is_initialized()

bool Slic3r::GUI::GLCanvas3D::LayersEditing::is_initialized ( ) const

private

{
    return wxGetApp().get_shader("variable_layer_height") != nullptr;
}

References is_initialized().

Referenced by is_initialized().

Here is the call graph for this function:

Here is the caller graph for this function:

object_max_z()

float Slic3r::GUI::GLCanvas3D::LayersEditing::object_max_z ( ) const

inline

{ return m_object_max_z; }

References m_object_max_z.

render_active_object_annotations()

void Slic3r::GUI::GLCanvas3D::LayersEditing::render_active_object_annotations ( const GLCanvas3D & canvas )

private

{
    if (!m_enabled)
        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;
 
    GLShaderProgram* shader = wxGetApp().get_shader("variable_layer_height");
    if (shader == nullptr)
        return;
 
    shader->start_using();
 
    shader->set_uniform("z_to_texture_row", float(m_layers_texture.cells - 1) / (float(m_layers_texture.width) * m_object_max_z));
    shader->set_uniform("z_texture_row_to_normalized", 1.0f / (float)m_layers_texture.height);
    shader->set_uniform("z_cursor", m_object_max_z * this->get_cursor_z_relative(canvas));
    shader->set_uniform("z_cursor_band_width", band_width);
    shader->set_uniform("object_max_z", m_object_max_z);
    shader->set_uniform("view_model_matrix", Transform3d::Identity());
    shader->set_uniform("projection_matrix", Transform3d::Identity());
    shader->set_uniform("view_normal_matrix", (Matrix3d)Matrix3d::Identity());
 
    glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
    glsafe(::glBindTexture(GL_TEXTURE_2D, m_z_texture_id));
 
    // Render the color bar
    if (!m_profile.background.is_initialized() || m_profile.old_canvas_width != cnv_width) {
        m_profile.old_canvas_width = cnv_width;
        m_profile.background.reset();
 
        GLModel::Geometry init_data;
        init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3T2 };
        init_data.reserve_vertices(4);
        init_data.reserve_indices(6);
 
        // vertices
        const float l = 1.0f - 2.0f * THICKNESS_BAR_WIDTH * cnv_inv_width;
        const float r = 1.0f;
        const float t = 1.0f;
        const float b = -1.0f;
        init_data.add_vertex(Vec3f(l, b, 0.0f), Vec3f::UnitZ(), Vec2f(0.0f, 0.0f));
        init_data.add_vertex(Vec3f(r, b, 0.0f), Vec3f::UnitZ(), Vec2f(1.0f, 0.0f));
        init_data.add_vertex(Vec3f(r, t, 0.0f), Vec3f::UnitZ(), Vec2f(1.0f, 1.0f));
        init_data.add_vertex(Vec3f(l, t, 0.0f), Vec3f::UnitZ(), Vec2f(0.0f, 1.0f));
 
        // indices
        init_data.add_triangle(0, 1, 2);
        init_data.add_triangle(2, 3, 0);
 
        m_profile.background.init_from(std::move(init_data));
    }
 
    m_profile.background.render();
 
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
 
    shader->stop_using();
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), band_width, Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLCanvas3D::get_canvas_size(), get_cursor_z_relative(), Slic3r::GUI::Size::get_height(), Slic3r::GUI::Size::get_width(), GL_TEXTURE_2D, GL_UNPACK_ALIGNMENT, glBindTexture, glPixelStorei, glsafe, m_enabled, m_layers_texture, m_object_max_z, m_profile, m_z_texture_id, Slic3r::GUI::GLModel::Geometry::P3N3T2, render_active_object_annotations(), Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), THICKNESS_BAR_WIDTH, and Slic3r::GUI::GLModel::Geometry::Triangles.

Referenced by render_active_object_annotations(), and render_overlay().

Here is the call graph for this function:

Here is the caller graph for this function:

render_overlay()

void Slic3r::GUI::GLCanvas3D::LayersEditing::render_overlay

(

GLCanvas3D &

canvas

)

{
    render_active_object_annotations(canvas);
    render_profile(canvas);
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), render_active_object_annotations(), render_overlay(), and render_profile().

Referenced by render_overlay().

Here is the call graph for this function:

Here is the caller graph for this function:

render_profile()

void Slic3r::GUI::GLCanvas3D::LayersEditing::render_profile ( const GLCanvas3D & canvas )

private

{
    if (!m_enabled)
        return;
 
    //FIXME show some kind of legend.
 
    if (!m_slicing_parameters)
        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;
 
    // Make the vertical bar a bit wider so the layer height curve does not touch the edge of the bar region.
    const float scale_x = THICKNESS_BAR_WIDTH / float(1.12 * m_slicing_parameters->max_layer_height);
    const float scale_y = cnv_height / m_object_max_z;
 
    const float cnv_inv_width  = 1.0f / cnv_width;
    const float cnv_inv_height = 1.0f / cnv_height;
 
    // Baseline
    if (!m_profile.baseline.is_initialized() || m_profile.old_layer_height_profile != m_layer_height_profile) {
        m_profile.baseline.reset();
 
        GLModel::Geometry init_data;
        init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P2};
        init_data.color = ColorRGBA::BLACK();
        init_data.reserve_vertices(2);
        init_data.reserve_indices(2);
 
        // vertices
        const float axis_x = 2.0f * ((cnv_width - THICKNESS_BAR_WIDTH + float(m_slicing_parameters->layer_height) * scale_x) * cnv_inv_width - 0.5f);
        init_data.add_vertex(Vec2f(axis_x, -1.0f));
        init_data.add_vertex(Vec2f(axis_x, 1.0f));
 
        // indices
        init_data.add_line(0, 1);
 
        m_profile.baseline.init_from(std::move(init_data));
    }
 
    if (!m_profile.profile.is_initialized() || m_profile.old_layer_height_profile != m_layer_height_profile) {
        m_profile.old_layer_height_profile = m_layer_height_profile;
        m_profile.profile.reset();
 
        GLModel::Geometry init_data;
        init_data.format = { GLModel::Geometry::EPrimitiveType::LineStrip, GLModel::Geometry::EVertexLayout::P2 };
        init_data.color = ColorRGBA::BLUE();
        init_data.reserve_vertices(m_layer_height_profile.size() / 2);
        init_data.reserve_indices(m_layer_height_profile.size() / 2);
 
        // vertices + indices
        for (unsigned int i = 0; i < (unsigned int)m_layer_height_profile.size(); i += 2) {
            init_data.add_vertex(Vec2f(2.0f * ((cnv_width - THICKNESS_BAR_WIDTH + float(m_layer_height_profile[i + 1]) * scale_x) * cnv_inv_width - 0.5f),
                                       2.0f * (float(m_layer_height_profile[i]) * scale_y * cnv_inv_height - 0.5)));
            init_data.add_index(i / 2);
        }
 
        m_profile.profile.init_from(std::move(init_data));
    }
 
#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();
        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("gap_size", 0.0f);
#if !SLIC3R_OPENGL_ES
        }
#endif // !SLIC3R_OPENGL_ES
        m_profile.baseline.render();
        m_profile.profile.render();
        shader->stop_using();
    }
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), Slic3r::GUI::GLModel::Geometry::add_index(), Slic3r::GUI::GLModel::Geometry::add_line(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::ColorRGBA::BLACK(), Slic3r::ColorRGBA::BLUE(), Slic3r::GUI::GLModel::Geometry::color, Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLCanvas3D::get_canvas_size(), Slic3r::GUI::OpenGLManager::get_gl_info(), Slic3r::GUI::Size::get_height(), Slic3r::GUI::Size::get_width(), Slic3r::GUI::GLModel::Geometry::Lines, Slic3r::GUI::GLModel::Geometry::LineStrip, m_enabled, m_layer_height_profile, m_object_max_z, m_profile, m_slicing_parameters, Slic3r::GUI::GLModel::Geometry::P2, render_profile(), Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), and THICKNESS_BAR_WIDTH.

Referenced by render_overlay(), and render_profile().

Here is the call graph for this function:

Here is the caller graph for this function:

render_variable_layer_height_dialog()

void Slic3r::GUI::GLCanvas3D::LayersEditing::render_variable_layer_height_dialog

(

GLCanvas3D &

canvas

)

                                                                                    {
    if (!m_enabled)
        return;
 
    ImGuiWrapper& imgui = *wxGetApp().imgui();
    const Size& cnv_size = canvas.get_canvas_size();
    float left_pos = canvas.m_main_toolbar.get_item("layersediting")->render_left_pos;
    float x = (1 + left_pos) * cnv_size.get_width() / 2;
 
    const auto canvas_width = cnv_size.get_width();
    if (abs(GLCanvas3D::LayersEditing::s_overlay_window_width) > 0.01f) {
        if (x + GLCanvas3D::LayersEditing::s_overlay_window_width > canvas_width) {
            if (GLCanvas3D::LayersEditing::s_overlay_window_width > canvas_width)
                x = 0;
            else
                x = canvas_width - GLCanvas3D::LayersEditing::s_overlay_window_width;
        }
    }
    x = std::max(x, 0.0f);
 
    imgui.set_next_window_pos(x, canvas.m_main_toolbar.get_height(), ImGuiCond_Always, 0.0f, 0.0f);
 
    imgui.push_toolbar_style(canvas.get_scale());
    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.0f * canvas.get_scale(), 4.0f * canvas.get_scale()));
    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(6.0f * canvas.get_scale(), 10.0f * canvas.get_scale()));
    imgui.begin(_L("Variable layer height"), ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse);
    const float sliders_width = imgui.scaled(7.0f);
    const float input_box_width = 1.5 * imgui.get_slider_icon_size().x;
 
    if (imgui.button(_L("Adaptive")))
        wxPostEvent((wxEvtHandler*)canvas.get_wxglcanvas(), Event<float>(EVT_GLCANVAS_ADAPTIVE_LAYER_HEIGHT_PROFILE, m_adaptive_quality));
    ImGui::SameLine();
    static float text_align = ImGui::GetCursorPosX();
    ImGui::AlignTextToFramePadding();
    text_align = std::max(text_align, ImGui::GetCursorPosX());
    ImGui::SetCursorPosX(text_align);
    imgui.text(_L("Quality / Speed"));
    if (ImGui::IsItemHovered()) {
        //ImGui::BeginTooltip();
        //ImGui::TextUnformatted(_L("Higher print quality versus higher print speed.").ToUTF8());
        //ImGui::EndTooltip();
    }
    ImGui::SameLine();
    static float slider_align = ImGui::GetCursorPosX();
    ImGui::PushItemWidth(sliders_width);
    m_adaptive_quality = std::clamp(m_adaptive_quality, 0.0f, 1.f);
    slider_align = std::max(slider_align, ImGui::GetCursorPosX());
    ImGui::SetCursorPosX(slider_align);
    imgui.bbl_slider_float_style("##adaptive_slider", &m_adaptive_quality, 0.0f, 1.f, "%.2f");
    ImGui::SameLine();
    static float input_align = ImGui::GetCursorPosX();
    ImGui::PushItemWidth(input_box_width);
    input_align = std::max(input_align, ImGui::GetCursorPosX());
    ImGui::SetCursorPosX(input_align);
    ImGui::BBLDragFloat("##adaptive_input", &m_adaptive_quality, 0.05f, 0.0f, 0.0f, "%.2f");
 
    if (imgui.button(_L_CONTEXT("Smooth", "Mesh action")))
        wxPostEvent((wxEvtHandler*)canvas.get_wxglcanvas(), HeightProfileSmoothEvent(EVT_GLCANVAS_SMOOTH_LAYER_HEIGHT_PROFILE, m_smooth_params));
    ImGui::SameLine();
    text_align = std::max(text_align, ImGui::GetCursorPosX());
    ImGui::SetCursorPosX(text_align);
    ImGui::AlignTextToFramePadding();
    imgui.text(_L("Radius"));
    ImGui::SameLine();
    slider_align = std::max(slider_align, ImGui::GetCursorPosX());
    ImGui::SetCursorPosX(slider_align);
    ImGui::PushItemWidth(sliders_width);
    int radius = (int)m_smooth_params.radius;
    int v_min = 1, v_max = 10;
    ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0f);
    ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, ImVec4(238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 0.00f));
    ImGui::PushStyleColor(ImGuiCol_FrameBgActive, ImVec4(238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 0.00f));
    ImGui::PushStyleColor(ImGuiCol_SliderGrab, ImVec4(0.81f, 0.81f, 0.81f, 1.0f));
    ImGui::PushStyleColor(ImGuiCol_SliderGrabActive, ImVec4(0.00f, 0.59f, 0.53f, 1.00f));
    if(ImGui::BBLSliderScalar("##radius_slider", ImGuiDataType_S32, &radius, &v_min, &v_max)){
        radius = std::clamp(radius, 1, 10);
        m_smooth_params.radius = (unsigned int)radius;
    }
    ImGui::PopStyleColor(4);
    ImGui::PopStyleVar();
    ImGui::SameLine();
    input_align = std::max(input_align, ImGui::GetCursorPosX());
    ImGui::SetCursorPosX(input_align);
    ImGui::PushItemWidth(input_box_width);
    ImGui::PushStyleColor(ImGuiCol_BorderActive, ImVec4(0.00f, 0.59f, 0.53f, 1.00f));
    ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, ImVec4(0.00f, 0.59f, 0.53f, 0.00f));
    ImGui::PushStyleColor(ImGuiCol_FrameBgActive, ImVec4(0.00f, 0.59f, 0.53f, 0.00f));
    ImGui::BBLDragScalar("##radius_input", ImGuiDataType_S32, &radius, 1, &v_min, &v_max);
    ImGui::PopStyleColor(3);
 
    imgui.bbl_checkbox("##keep_min", m_smooth_params.keep_min);
    ImGui::SameLine();
    ImGui::AlignTextToFramePadding();
    imgui.text(_L("Keep min"));
 
    ImGui::Separator();
 
    const wxString shift = GUI::shortkey_shift_prefix();
    std::vector<std::pair<wxString, wxString>> shortcuts = {
        {_L("Left mouse button"),          _L("Add detail")},
        {_L("Right mouse button"),         _L("Remove detail")},
        {shift + _L("Left mouse button"),  _L("Reset to base")},
        {shift + _L("Right mouse button"), _L("Smoothing")},
        {_L("Mouse wheel"),                _L("Increase/decrease edit area")}
    };
 
    float y = canvas.m_main_toolbar.get_height();
    GLGizmoUtils::render_tooltip_button(&imgui, canvas, shortcuts, x, y);
 
    ImGui::SameLine();
    imgui.disabled_begin(check_object_layers_fixed(*m_slicing_parameters, m_layer_height_profile));
    if (imgui.button(_L("Reset"))) {
        wxPostEvent((wxEvtHandler*) canvas.get_wxglcanvas(), SimpleEvent(EVT_GLCANVAS_RESET_LAYER_HEIGHT_PROFILE));
    }
    imgui.disabled_end();
 
    ImGui::SameLine();
    GLGizmoUtils::begin_right_aligned_buttons({_L("Done")});
    if (imgui.button(_L("Done"))) {
        m_enabled = false;
 
        GLToolbarItem* item = canvas.m_main_toolbar.get_item("layersediting");
        item->set_state(GLToolbarItem::Normal);
 
        canvas.set_as_dirty();
        canvas.request_extra_frame();
    }
 
    GLCanvas3D::LayersEditing::s_overlay_window_width = ImGui::GetWindowSize().x;
    imgui.end();
    ImGui::PopStyleVar(2);
    imgui.pop_toolbar_style();
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), _L, _L_CONTEXT, Slic3r::GUI::ImGuiWrapper::bbl_checkbox(), Slic3r::GUI::ImGuiWrapper::bbl_slider_float_style(), Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::GLGizmoUtils::begin_right_aligned_buttons(), Slic3r::GUI::ImGuiWrapper::button(), Slic3r::check_object_layers_fixed(), Slic3r::GUI::ImGuiWrapper::disabled_begin(), Slic3r::GUI::ImGuiWrapper::disabled_end(), Slic3r::GUI::ImGuiWrapper::end(), Slic3r::GUI::GLCanvas3D::get_canvas_size(), Slic3r::GUI::GLToolbar::get_height(), Slic3r::GUI::GLToolbar::get_item(), Slic3r::GUI::GLCanvas3D::get_scale(), Slic3r::GUI::Size::get_width(), Slic3r::GUI::GLCanvas3D::get_wxglcanvas(), m_adaptive_quality, m_enabled, m_layer_height_profile, Slic3r::GUI::GLCanvas3D::m_main_toolbar, m_slicing_parameters, m_smooth_params, Slic3r::GUI::GLToolbarItem::Normal, Slic3r::GUI::ImGuiWrapper::pop_toolbar_style(), Slic3r::GUI::ImGuiWrapper::push_toolbar_style(), Slic3r::GUI::GLToolbarItem::render_left_pos, Slic3r::GUI::GLGizmoUtils::render_tooltip_button(), render_variable_layer_height_dialog(), Slic3r::GUI::GLCanvas3D::request_extra_frame(), s_overlay_window_width, Slic3r::GUI::ImGuiWrapper::scaled(), Slic3r::GUI::GLCanvas3D::set_as_dirty(), Slic3r::GUI::ImGuiWrapper::set_next_window_pos(), Slic3r::GUI::GLToolbarItem::set_state(), Slic3r::GUI::shortkey_shift_prefix(), and Slic3r::GUI::ImGuiWrapper::text().

Referenced by render_variable_layer_height_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

render_volumes()

void Slic3r::GUI::GLCanvas3D::LayersEditing::render_volumes	(	const GLCanvas3D &	canvas,
		const GLVolumeCollection &	volumes )

{
    assert(this->is_allowed());
    assert(this->last_object_id != -1);
 
    GLShaderProgram* current_shader = wxGetApp().get_current_shader();
    ScopeGuard guard([current_shader]() { if (current_shader != nullptr) current_shader->start_using(); });
    if (current_shader != nullptr)
        current_shader->stop_using();
 
    GLShaderProgram* shader = wxGetApp().get_shader("variable_layer_height");
    if (shader == nullptr)
        return;
 
    shader->start_using();
 
    generate_layer_height_texture();
 
    // Uniforms were resolved, go ahead using the layer editing shader.
    shader->set_uniform("z_to_texture_row", float(m_layers_texture.cells - 1) / (float(m_layers_texture.width) * float(m_object_max_z)));
    shader->set_uniform("z_texture_row_to_normalized", 1.0f / float(m_layers_texture.height));
    shader->set_uniform("z_cursor", float(m_object_max_z) * float(this->get_cursor_z_relative(canvas)));
    shader->set_uniform("z_cursor_band_width", float(this->band_width));
 
    const Camera& camera = wxGetApp().plater()->get_camera();
    shader->set_uniform("projection_matrix", camera.get_projection_matrix());
 
    // Initialize the layer height texture mapping.
    const GLsizei w = (GLsizei)m_layers_texture.width;
    const GLsizei h = (GLsizei)m_layers_texture.height;
    const GLsizei half_w = w / 2;
    const GLsizei half_h = h / 2;
    glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
    glsafe(::glBindTexture(GL_TEXTURE_2D, m_z_texture_id));
    glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0));
    glsafe(::glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA, half_w, half_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0));
    glsafe(::glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, m_layers_texture.data.data()));
    glsafe(::glTexSubImage2D(GL_TEXTURE_2D, 1, 0, 0, half_w, half_h, GL_RGBA, GL_UNSIGNED_BYTE, m_layers_texture.data.data() + m_layers_texture.width * m_layers_texture.height * 4));
    for (GLVolume* glvolume : volumes.volumes) {
        // Render the object using the layer editing shader and texture.
        if (!glvolume->is_active || glvolume->composite_id.object_id != this->last_object_id || glvolume->is_modifier)
            continue;
 
        shader->set_uniform("volume_world_matrix", glvolume->world_matrix());
        shader->set_uniform("object_max_z", 0.0f);
        const Transform3d& view_matrix = camera.get_view_matrix();
        const Transform3d model_matrix = glvolume->world_matrix();
        shader->set_uniform("view_model_matrix", view_matrix * model_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);
 
        glvolume->render();
    }
    // Revert back to the previous shader.
    glBindTexture(GL_TEXTURE_2D, 0);
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), band_width, Slic3r::GUI::GLCanvas3D::camera, Slic3r::GLVolume::composite_id, Slic3r::generate_layer_height_texture(), get_cursor_z_relative(), GL_RGBA, GL_TEXTURE_2D, GL_UNPACK_ALIGNMENT, GL_UNSIGNED_BYTE, glBindTexture, glPixelStorei, glsafe, glTexImage2D, glTexSubImage2D, is_allowed(), last_object_id, m_layers_texture, m_object_max_z, m_z_texture_id, Slic3r::GLVolume::CompositeID::object_id, Slic3r::GLVolume::render(), render_volumes(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), Slic3r::GLVolumeCollection::volumes, and Slic3r::GLVolume::world_matrix().

Referenced by render_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_layer_height_profile()

void Slic3r::GUI::GLCanvas3D::LayersEditing::reset_layer_height_profile

(

GLCanvas3D &

canvas

)

{
    const_cast<ModelObject*>(m_model_object)->layer_height_profile.clear();
    m_layer_height_profile.clear();
    m_layers_texture.valid = false;
    canvas.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
    wxGetApp().obj_list()->update_info_items(last_object_id);
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), last_object_id, m_layer_height_profile, m_layers_texture, m_model_object, Slic3r::GUI::GLCanvas3D::post_event(), and reset_layer_height_profile().

Referenced by reset_layer_height_profile().

Here is the call graph for this function:

Here is the caller graph for this function:

select_object()

void Slic3r::GUI::GLCanvas3D::LayersEditing::select_object	(	const Model &	model,
		int	object_id )

{
    const ModelObject* model_object_new = (object_id >= 0) ? model.objects[object_id] : nullptr;
    // Maximum height of an object changes when the object gets rotated or scaled.
    // Changing maximum height of an object will invalidate the layer heigth editing profile.
    // m_model_object->bounding_box() is cached, therefore it is cheap even if this method is called frequently.
    const float new_max_z = (model_object_new == nullptr) ? 0.0f : static_cast<float>(model_object_new->max_z());
 
    if (m_model_object != model_object_new || this->last_object_id != object_id || m_object_max_z != new_max_z ||
        (model_object_new != nullptr && m_model_object->id() != model_object_new->id())) {
        m_layer_height_profile.clear();
        delete m_slicing_parameters;
        m_slicing_parameters = nullptr;
        m_layers_texture.valid = false;
        this->last_object_id = object_id;
        m_model_object = model_object_new;
        m_object_max_z = new_max_z;
    }
}

References Slic3r::ObjectBase::id(), last_object_id, m_layer_height_profile, m_layers_texture, m_model_object, m_object_max_z, m_slicing_parameters, Slic3r::ModelObject::max_z(), Slic3r::Model::objects, and select_object().

Referenced by select_object().

Here is the call graph for this function:

Here is the caller graph for this function:

set_config()

void Slic3r::GUI::GLCanvas3D::LayersEditing::set_config

(

const DynamicPrintConfig *

config

)

{
    m_config = config;
    delete m_slicing_parameters;
    m_slicing_parameters = nullptr;
    m_layers_texture.valid = false;
    m_layer_height_profile.clear();
}

References m_config, m_layer_height_profile, m_layers_texture, m_slicing_parameters, and set_config().

Referenced by set_config().

Here is the call graph for this function:

Here is the caller graph for this function:

set_enabled()

void Slic3r::GUI::GLCanvas3D::LayersEditing::set_enabled ( bool enabled )

inline

{ m_enabled = is_allowed() && enabled; }

References is_allowed(), and m_enabled.

Here is the call graph for this function:

set_shrinkage_compensation()

void Slic3r::GUI::GLCanvas3D::LayersEditing::set_shrinkage_compensation ( const Vec3d & shrinkage_compensation )

inline

{ m_shrinkage_compensation = shrinkage_compensation; };

References m_shrinkage_compensation.

smooth_layer_height_profile()

void Slic3r::GUI::GLCanvas3D::LayersEditing::smooth_layer_height_profile	(	GLCanvas3D &	canvas,
		const HeightProfileSmoothingParams &	smoothing_params )

{
    this->update_slicing_parameters();
    m_layer_height_profile = smooth_height_profile(m_layer_height_profile, *m_slicing_parameters, smoothing_params);
    const_cast<ModelObject*>(m_model_object)->layer_height_profile.set(m_layer_height_profile);
    m_layers_texture.valid = false;
    canvas.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
    wxGetApp().obj_list()->update_info_items(last_object_id);
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), last_object_id, m_layer_height_profile, m_layers_texture, m_model_object, m_slicing_parameters, Slic3r::GUI::GLCanvas3D::post_event(), Slic3r::smooth_height_profile(), smooth_layer_height_profile(), and update_slicing_parameters().

Referenced by smooth_layer_height_profile().

Here is the call graph for this function:

Here is the caller graph for this function:

thickness_bar_width()

float Slic3r::GUI::GLCanvas3D::LayersEditing::thickness_bar_width ( const GLCanvas3D & canvas )

staticprivate

{
    return
#if ENABLE_RETINA_GL
        canvas.get_canvas_size().get_scale_factor()
#else
        canvas.get_wxglcanvas()->GetContentScaleFactor()
#endif
        * THICKNESS_BAR_WIDTH;
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), Slic3r::GUI::GLCanvas3D::get_canvas_size(), Slic3r::GUI::Size::get_scale_factor(), Slic3r::GUI::GLCanvas3D::get_wxglcanvas(), THICKNESS_BAR_WIDTH, and thickness_bar_width().

Referenced by get_bar_rect_screen(), and thickness_bar_width().

Here is the call graph for this function:

Here is the caller graph for this function:

update_slicing_parameters()

void Slic3r::GUI::GLCanvas3D::LayersEditing::update_slicing_parameters ( )

private

{
    if (m_slicing_parameters == nullptr) {
        m_slicing_parameters = new SlicingParameters();
        *m_slicing_parameters = PrintObject::slicing_parameters(*m_config, *m_model_object, m_object_max_z, m_shrinkage_compensation);
    }
 
}

References m_config, m_model_object, m_object_max_z, m_shrinkage_compensation, m_slicing_parameters, Slic3r::PrintObject::slicing_parameters(), and update_slicing_parameters().

Referenced by adaptive_layer_height_profile(), adjust_layer_height_profile(), generate_layer_height_texture(), smooth_layer_height_profile(), and update_slicing_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

band_width

float Slic3r::GUI::GLCanvas3D::LayersEditing::band_width { 2.0f }

{ 2.0f };

Referenced by adjust_layer_height_profile(), render_active_object_annotations(), and render_volumes().

last_action

LayerHeightEditActionType Slic3r::GUI::GLCanvas3D::LayersEditing::last_action { LAYER_HEIGHT_EDIT_ACTION_INCREASE }

{ LAYER_HEIGHT_EDIT_ACTION_INCREASE };

Referenced by adjust_layer_height_profile().

last_object_id

int Slic3r::GUI::GLCanvas3D::LayersEditing::last_object_id { -1 }

{ -1 };

Referenced by accept_changes(), adaptive_layer_height_profile(), render_volumes(), reset_layer_height_profile(), select_object(), and smooth_layer_height_profile().

last_z

float Slic3r::GUI::GLCanvas3D::LayersEditing::last_z { 0.0f }

{ 0.0f };

Referenced by adjust_layer_height_profile().

m_adaptive_quality

float Slic3r::GUI::GLCanvas3D::LayersEditing::m_adaptive_quality { 0.5f }

mutableprivate

{ 0.5f };

Referenced by render_variable_layer_height_dialog().

m_config

const DynamicPrintConfig* Slic3r::GUI::GLCanvas3D::LayersEditing::m_config { nullptr }

private

{ nullptr };

Referenced by set_config(), and update_slicing_parameters().

m_enabled

bool Slic3r::GUI::GLCanvas3D::LayersEditing::m_enabled { false }

private

{ false };

Referenced by get_tooltip(), is_enabled(), render_active_object_annotations(), render_profile(), render_variable_layer_height_dialog(), and set_enabled().

m_layer_height_profile

std::vector<double> Slic3r::GUI::GLCanvas3D::LayersEditing::m_layer_height_profile

private

Referenced by accept_changes(), adaptive_layer_height_profile(), adjust_layer_height_profile(), generate_layer_height_texture(), get_tooltip(), render_profile(), render_variable_layer_height_dialog(), reset_layer_height_profile(), select_object(), set_config(), and smooth_layer_height_profile().

m_layers_texture

LayersTexture Slic3r::GUI::GLCanvas3D::LayersEditing::m_layers_texture

private

Referenced by adaptive_layer_height_profile(), adjust_layer_height_profile(), generate_layer_height_texture(), render_active_object_annotations(), render_volumes(), reset_layer_height_profile(), select_object(), set_config(), and smooth_layer_height_profile().

m_model_object

const ModelObject* Slic3r::GUI::GLCanvas3D::LayersEditing::m_model_object { nullptr }

private

{ nullptr };

Referenced by accept_changes(), adaptive_layer_height_profile(), adjust_layer_height_profile(), generate_layer_height_texture(), reset_layer_height_profile(), select_object(), smooth_layer_height_profile(), and update_slicing_parameters().

m_object_max_z

float Slic3r::GUI::GLCanvas3D::LayersEditing::m_object_max_z { 0.0f }

private

{ 0.0f };

Referenced by get_tooltip(), object_max_z(), render_active_object_annotations(), render_profile(), render_volumes(), select_object(), and update_slicing_parameters().

m_profile

Profile Slic3r::GUI::GLCanvas3D::LayersEditing::m_profile

Referenced by render_active_object_annotations(), and render_profile().

m_shrinkage_compensation

Vec3d Slic3r::GUI::GLCanvas3D::LayersEditing::m_shrinkage_compensation { Vec3d::Ones() }

private

{ Vec3d::Ones() };

Referenced by set_shrinkage_compensation(), and update_slicing_parameters().

m_slicing_parameters

SlicingParameters* Slic3r::GUI::GLCanvas3D::LayersEditing::m_slicing_parameters { nullptr }

private

{ nullptr };

Referenced by ~LayersEditing(), adaptive_layer_height_profile(), adjust_layer_height_profile(), generate_layer_height_texture(), render_profile(), render_variable_layer_height_dialog(), select_object(), set_config(), smooth_layer_height_profile(), and update_slicing_parameters().

m_smooth_params

HeightProfileSmoothingParams Slic3r::GUI::GLCanvas3D::LayersEditing::m_smooth_params

mutableprivate

Referenced by render_variable_layer_height_dialog().

m_z_texture_id

unsigned int Slic3r::GUI::GLCanvas3D::LayersEditing::m_z_texture_id { 0 }

private

{ 0 };

Referenced by ~LayersEditing(), init(), is_allowed(), render_active_object_annotations(), and render_volumes().

s_overlay_window_width

float Slic3r::GUI::GLCanvas3D::LayersEditing::s_overlay_window_width

staticprivate

Referenced by get_overlay_window_width(), and render_variable_layer_height_dialog().

state

EState Slic3r::GUI::GLCanvas3D::LayersEditing::state { Unknown }

{ Unknown };

strength

float Slic3r::GUI::GLCanvas3D::LayersEditing::strength { 0.005f }

{ 0.005f };

Referenced by adjust_layer_height_profile().

THICKNESS_BAR_WIDTH

const float Slic3r::GUI::GLCanvas3D::LayersEditing::THICKNESS_BAR_WIDTH = 70.0f

static

Referenced by render_active_object_annotations(), render_profile(), and thickness_bar_width().

---

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