Slic3r::GUI::Bed3D Class Reference

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

Collaboration diagram for Slic3r::GUI::Bed3D:

Classes
class	Axes

Public Types
enum class	Type : unsigned char { System , Custom }

Public Member Functions
	Bed3D ()=default
	~Bed3D ()=default
bool	set_shape (const Pointfs &printable_area, const double printable_height, std::vector< Pointfs > extruder_areas, std::vector< double > extruder_heights, const std::string &custom_model, bool force_as_custom=false, const Vec2d position=Vec2d::Zero(), bool with_reset=true)
void	set_position (Vec2d &position)
void	set_axes_mode (bool origin)
void	set_axes_origin (const Vec3d &origin)
const Vec2d &	get_position () const
const BuildVolume &	build_volume () const
BuildVolume &	build_volume ()
Type	get_type () const
bool	is_custom () const
BuildVolume_Type	get_build_volume_type () const
const BoundingBoxf3 &	extended_bounding_box () const
const BoundingBoxf3 &	printable_bounding_box () const
bool	contains (const Point &point) const
Point	point_projection (const Point &point) const
void	render (GLCanvas3D &canvas, const Transform3d &view_matrix, const Transform3d &projection_matrix, bool bottom, float scale_factor, bool show_axes)
void	on_change_color_mode (bool is_dark)

Static Public Member Functions
static void	update_render_colors ()
static void	load_render_colors ()

Static Public Attributes
static ColorRGBA	DEFAULT_MODEL_COLOR = { 0.3255f, 0.337f, 0.337f, 1.0f }
static ColorRGBA	DEFAULT_MODEL_COLOR_DARK = { 0.255f, 0.255f, 0.283f, 1.0f }
static ColorRGBA	DEFAULT_SOLID_GRID_COLOR = { 0.9f, 0.9f, 0.9f, 1.0f }
static ColorRGBA	DEFAULT_TRANSPARENT_GRID_COLOR = { 0.9f, 0.9f, 0.9f, 0.6f }
static ColorRGBA	AXIS_X_COLOR = ColorRGBA::X()
static ColorRGBA	AXIS_Y_COLOR = ColorRGBA::Y()
static ColorRGBA	AXIS_Z_COLOR = ColorRGBA::Z()

Private Member Functions
BoundingBoxf3	calc_printable_bounding_box () const
BoundingBoxf3	calc_extended_bounding_box () const
void	update_model_offset ()
void	update_bed_triangles ()
void	render_internal (GLCanvas3D &canvas, const Transform3d &view_matrix, const Transform3d &projection_matrix, bool bottom, float scale_factor, bool show_axes)
void	render_axes ()
void	render_system (GLCanvas3D &canvas, const Transform3d &view_matrix, const Transform3d &projection_matrix, bool bottom)
void	render_model (const Transform3d &view_matrix, const Transform3d &projection_matrix)
void	render_custom (GLCanvas3D &canvas, const Transform3d &view_matrix, const Transform3d &projection_matrix, bool bottom)
void	render_default (bool bottom, const Transform3d &view_matrix, const Transform3d &projection_matrix)
void	render_gravity_arrow (const Transform3d &view_matrix, const Transform3d &projection_matrix)

Static Private Member Functions
static std::tuple< Type, std::string, std::string >	detect_type (const Pointfs &shape)

Private Attributes
BuildVolume	m_build_volume
Type	m_type { Type::System }
std::string	m_model_filename
BoundingBoxf3	m_extended_bounding_box
BoundingBoxf3	m_printable_bounding_box
GLModel	m_triangles
GLModel	m_model
Vec3d	m_model_offset { Vec3d::Zero() }
GLModel	m_gravity_arrow
float	m_gravity_arrow_length { 0.f }
Axes	m_axes
float	m_scale_factor { 1.0f }
Vec2d	m_position { Vec2d::Zero() }
std::vector< Vec2d >	m_bed_shape
std::vector< std::vector< Vec2d > >	m_extruder_shapes
std::vector< double >	m_extruder_heights
bool	m_is_dark = false

Detailed Description

Member Enumeration Documentation

Type

enum class Slic3r::GUI::Bed3D::Type : unsigned char

strong

Enumerator
System
Custom

    {
        // The print bed model and texture are available from some printer preset.
        System,
        // The print bed model is unknown, thus it is rendered procedurally.
        Custom
    };

Constructor & Destructor Documentation

Bed3D()

Slic3r::GUI::Bed3D::Bed3D ( )

default

~Bed3D()

Slic3r::GUI::Bed3D::~Bed3D ( )

default

References Slic3r::printable_area(), and Slic3r::printable_height().

Here is the call graph for this function:

Member Function Documentation

build_volume() [1/2]

BuildVolume & Slic3r::GUI::Bed3D::build_volume ( )

inline

{ return m_build_volume; }

References m_build_volume.

build_volume() [2/2]

const BuildVolume & Slic3r::GUI::Bed3D::build_volume ( ) const

inline

{ return m_build_volume; }

References m_build_volume.

Referenced by Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::Plater::priv::load_model_objects(), Slic3r::GUI::Plater::priv::scale_selection_to_fit_print_volume(), Slic3r::GUI::Plater::priv::update(), and update_bed_triangles().

Here is the caller graph for this function:

calc_extended_bounding_box()

BoundingBoxf3 Slic3r::GUI::Bed3D::calc_extended_bounding_box ( ) const

private

{
    BoundingBoxf3 out;
    out.merge(m_printable_bounding_box);
    BoundingBoxf3 model_bb = m_model.get_bounding_box();
    if (model_bb.defined) {
        model_bb.translate(m_model_offset);
        out.merge(model_bb);
    }
    return out;
}

References Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::defined, m_model, m_model_offset, m_printable_bounding_box, Slic3r::BoundingBox3Base< PointType >::merge(), and Slic3r::BoundingBox3Base< PointType >::translate().

Referenced by update_bed_triangles(), and update_model_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_printable_bounding_box()

BoundingBoxf3 Slic3r::GUI::Bed3D::calc_printable_bounding_box ( ) const

private

{
    BoundingBoxf3 out{m_build_volume.bounding_volume()};
 
    const Vec3d size = out.size();
    // ensures that the bounding box is set as defined or the following calls to merge() will not work as intented
    if (size.x() > 0.0 && size.y() > 0.0 && !out.defined)
        out.defined = true;
    // Reset the build volume Z, we don't want to zoom to the top of the build volume if it is empty.
    out.min.z() = 0.0;
    out.max.z() = 0.0;
    // extend to contain axes
    // BBS: add part plate related logic.
    Vec3d offset{m_position.x(), m_position.y(), 0.f};
    // out.merge(m_axes.get_origin() + offset + m_axes.get_total_length() * Vec3d::Ones());
    out.merge(Vec3d(0.f, 0.f, GROUND_Z) + offset + m_axes.get_total_length() * Vec3d::Ones());
    out.merge(out.min + Vec3d(-Axes::DefaultTipRadius, -Axes::DefaultTipRadius, out.max.z()));
    return out;
}

References Slic3r::GUI::Bed3D::Axes::DefaultTipRadius, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::defined, GROUND_Z, m_axes, m_build_volume, m_position, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::offset(), and Slic3r::BoundingBox3Base< PointType >::size().

Referenced by update_bed_triangles(), and update_model_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

contains()

bool Slic3r::GUI::Bed3D::contains

(

const Point &

point

)

const

detect_type()

std::tuple< Bed3D::Type, std::string, std::string > Slic3r::GUI::Bed3D::detect_type ( const Pointfs & shape )

staticprivate

{
    auto bundle = wxGetApp().preset_bundle;
    if (bundle != nullptr) {
        const Preset* curr = &bundle->printers.get_selected_preset();
        while (curr != nullptr) {
            if (curr->config.has("printable_area")) {
                std::string texture_filename, model_filename;
                if (shape == make_counter_clockwise(dynamic_cast<const ConfigOptionPoints*>(curr->config.option("printable_area"))->values)) {
                    if (curr->is_system)
                        model_filename = PresetUtils::system_printer_bed_model(*curr);
                    else {
                        auto *printer_model = curr->config.opt<ConfigOptionString>("printer_model");
                        if (printer_model != nullptr && ! printer_model->value.empty()) {
                            model_filename = bundle->get_stl_model_for_printer_model(printer_model->value);
                        }
                    }
                    //std::string model_filename = PresetUtils::system_printer_bed_model(*curr);
                    //std::string texture_filename = PresetUtils::system_printer_bed_texture(*curr);
                    if (!model_filename.empty())
                        return { Type::System, model_filename, texture_filename };
                }
            }
 
            curr = bundle->printers.get_preset_parent(*curr);
        }
    }
 
    return { Type::Custom, {}, {} };
}

References Slic3r::Preset::config, Custom, Slic3r::ConfigOptionResolver::has(), Slic3r::Preset::is_system, Slic3r::make_counter_clockwise(), Slic3r::GUI::model_filename, Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), System, Slic3r::PresetUtils::system_printer_bed_model(), and Slic3r::ConfigOptionVector< T >::values.

Referenced by set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

extended_bounding_box()

const BoundingBoxf3 & Slic3r::GUI::Bed3D::extended_bounding_box ( ) const

inline

{ return m_extended_bounding_box; }

References m_extended_bounding_box.

get_build_volume_type()

BuildVolume_Type Slic3r::GUI::Bed3D::get_build_volume_type ( ) const

inline

{ return m_build_volume.type(); }

References m_build_volume.

get_position()

const Vec2d & Slic3r::GUI::Bed3D::get_position ( ) const

inline

{ return m_position; }

References m_position.

get_type()

Type Slic3r::GUI::Bed3D::get_type ( ) const

inline

{ return m_type; }

References m_type.

is_custom()

bool Slic3r::GUI::Bed3D::is_custom ( ) const

inline

{ return m_type == Type::Custom; }

References Custom, and m_type.

load_render_colors()

void Slic3r::GUI::Bed3D::load_render_colors ( )

static

{
    RenderColor::colors[RenderCol_Axis_X] = ImGuiWrapper::to_ImVec4(Bed3D::AXIS_X_COLOR);
    RenderColor::colors[RenderCol_Axis_Y] = ImGuiWrapper::to_ImVec4(Bed3D::AXIS_Y_COLOR);
    RenderColor::colors[RenderCol_Axis_Z] = ImGuiWrapper::to_ImVec4(Bed3D::AXIS_Z_COLOR);
}

References AXIS_X_COLOR, AXIS_Y_COLOR, AXIS_Z_COLOR, Slic3r::RenderColor::colors, RenderCol_Axis_X, RenderCol_Axis_Y, RenderCol_Axis_Z, and Slic3r::GUI::ImGuiWrapper::to_ImVec4().

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

Here is the call graph for this function:

Here is the caller graph for this function:

on_change_color_mode()

void Slic3r::GUI::Bed3D::on_change_color_mode

(

bool

is_dark

)

{
    m_is_dark = is_dark;
}

References is_dark(), and m_is_dark.

Here is the call graph for this function:

point_projection()

Point Slic3r::GUI::Bed3D::point_projection

(

const Point &

point

)

const

References is_dark().

Here is the call graph for this function:

printable_bounding_box()

const BoundingBoxf3 & Slic3r::GUI::Bed3D::printable_bounding_box ( ) const

inline

{ return m_printable_bounding_box; }

References m_printable_bounding_box.

render()

void Slic3r::GUI::Bed3D::render	(	GLCanvas3D &	canvas,
		const Transform3d &	view_matrix,
		const Transform3d &	projection_matrix,
		bool	bottom,
		float	scale_factor,
		bool	show_axes )

{
    render_internal(canvas, view_matrix, projection_matrix, bottom, scale_factor, show_axes);
}

References render_internal().

Here is the call graph for this function:

render_axes()

void Slic3r::GUI::Bed3D::render_axes ( )

private

{
    if (m_build_volume.valid())
        m_axes.render();
}

References m_axes, and m_build_volume.

Referenced by render_internal().

Here is the caller graph for this function:

render_custom()

void Slic3r::GUI::Bed3D::render_custom ( GLCanvas3D & canvas, const Transform3d & view_matrix, const Transform3d & projection_matrix, bool bottom )

private

{
    if (m_model_filename.empty()) {
        render_default(bottom, view_matrix, projection_matrix);
        return;
    }
 
    if (!bottom)
        render_model(view_matrix, projection_matrix);
 
    /*if (show_texture)
        render_texture(bottom, canvas);*/
}

References m_model_filename, render_default(), and render_model().

Referenced by render_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

render_default()

void Slic3r::GUI::Bed3D::render_default ( bool bottom, const Transform3d & view_matrix, const Transform3d & projection_matrix )

private

{
    // m_texture.reset();
 
    update_bed_triangles();
 
    GLShaderProgram* shader = wxGetApp().get_shader("flat");
    if (shader != nullptr) {
        shader->start_using();
 
        shader->set_uniform("view_model_matrix", view_matrix);
        shader->set_uniform("projection_matrix", projection_matrix);
 
        glsafe(::glEnable(GL_DEPTH_TEST));
        glsafe(::glEnable(GL_BLEND));
        glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
        if (m_model.get_filename().empty() && !bottom) {
            // draw background
            glsafe(::glDepthMask(GL_FALSE));
            ColorRGBA color = m_is_dark ? DEFAULT_MODEL_COLOR_DARK : DEFAULT_MODEL_COLOR;   // ORCA add dark mode support
            color = ColorRGBA(color[0] * 0.8f, color[1] * 0.8f,color[2] * 0.8f, color[3]);  // ORCA shift color a darker tone to fix difference between flat / gouraud_light shader
            m_triangles.set_color(color);
            m_triangles.render();
            glsafe(::glDepthMask(GL_TRUE));
        }
 
        /*if (!picking) {
            // draw grid
            glsafe(::glLineWidth(1.5f * m_scale_factor));
            m_gridlines.set_color(picking ? DEFAULT_SOLID_GRID_COLOR : DEFAULT_TRANSPARENT_GRID_COLOR);
            m_gridlines.render();
        }*/
 
        glsafe(::glDisable(GL_BLEND));
 
        shader->stop_using();
    }
}

References DEFAULT_MODEL_COLOR, DEFAULT_MODEL_COLOR_DARK, GL_BLEND, GL_DEPTH_TEST, GL_FALSE, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_TRUE, glBlendFunc, glDepthMask, glDisable, glEnable, glsafe, m_is_dark, m_model, m_triangles, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), and update_bed_triangles().

Referenced by render_custom().

Here is the call graph for this function:

Here is the caller graph for this function:

render_gravity_arrow()

void Slic3r::GUI::Bed3D::render_gravity_arrow ( const Transform3d & view_matrix, const Transform3d & projection_matrix )

private

{
    // build_plate_tilt_{x,y} are kept in sync with the belt tilt (see TabPrinter), so
    // reading them here covers both belt and non-belt tilted printers.
    const Vec3d up_dir = build_plate_tilt_up_direction();
    if (up_dir == Vec3d::UnitZ()) {
        m_gravity_arrow.reset();
        return;
    }
 
    // A plain line along the tilted "up" direction -- the way the layers lean, i.e.
    // the gantry -- drawn like the bed axes (no tip: the other direction is not
    // possible) and shorter than them, so it reads as a hint inside the YZ corner.
    const float length = 0.6f * m_axes.get_total_length();
    if (!m_gravity_arrow.is_initialized() || m_gravity_arrow_length != length) {
        m_gravity_arrow.reset();
        m_gravity_arrow.init_from(smooth_cylinder(16, /*Radius*/ length / 75.f, length));
        m_gravity_arrow_length = length;
    }
 
    // The cylinder model points along +Z. Compute the rotation that aligns it with
    // up_dir: rotation axis = cross(+Z, up_dir), angle = acos(dot(+Z, up_dir)).
    Vec3d from = Vec3d::UnitZ();
    Vec3d to   = up_dir;
    double dot  = from.dot(to);
    Transform3d rot = Transform3d::Identity();
    if (dot < -0.9999) {
        // Nearly opposite -- rotate 180 degrees around X
        rot = Eigen::AngleAxisd(M_PI, Vec3d::UnitX()) * rot;
    } else if (dot < 0.9999) {
        Vec3d axis  = from.cross(to).normalized();
        double angle = std::acos(std::clamp(dot, -1.0, 1.0));
        rot = Eigen::AngleAxisd(angle, axis) * rot;
    }
 
    GLShaderProgram* shader = wxGetApp().get_shader("flat");
    if (shader == nullptr)
        return;
 
    glsafe(::glEnable(GL_DEPTH_TEST));
    shader->start_using();
 
    const Camera& camera = wxGetApp().plater()->get_camera();
    Transform3d model_matrix = Eigen::Translation3d(m_axes.get_origin()) * rot;
    shader->set_uniform("view_model_matrix", camera.get_view_matrix() * model_matrix);
    shader->set_uniform("projection_matrix", camera.get_projection_matrix());
 
    m_gravity_arrow.set_color({ 1.0f, 0.85f, 0.0f, 1.0f }); // yellow
    m_gravity_arrow.render();
 
    shader->stop_using();
}

References Slic3r::angle(), Slic3r::GUI::build_plate_tilt_up_direction(), Slic3r::dot(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), GL_DEPTH_TEST, glEnable, glsafe, Slic3r::length(), m_axes, m_gravity_arrow, m_gravity_arrow_length, M_PI, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GUI::smooth_cylinder(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Referenced by render_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

render_internal()

void Slic3r::GUI::Bed3D::render_internal ( GLCanvas3D & canvas, const Transform3d & view_matrix, const Transform3d & projection_matrix, bool bottom, float scale_factor, bool show_axes )

private

{
    m_scale_factor = scale_factor;
 
    if (show_axes)
        render_axes();
 
    glsafe(::glEnable(GL_DEPTH_TEST));
 
    m_model.set_color(m_is_dark ? DEFAULT_MODEL_COLOR_DARK : DEFAULT_MODEL_COLOR);
 
    switch (m_type)
    {
    case Type::System: { render_system(canvas, view_matrix, projection_matrix, bottom); break; }
    default:
    case Type::Custom: { render_custom(canvas, view_matrix, projection_matrix, bottom); break; }
    }
 
    render_gravity_arrow(view_matrix, projection_matrix);
 
    glsafe(::glDisable(GL_DEPTH_TEST));
}

References Custom, DEFAULT_MODEL_COLOR, DEFAULT_MODEL_COLOR_DARK, GL_DEPTH_TEST, glDisable, glEnable, glsafe, m_is_dark, m_model, m_scale_factor, m_type, render_axes(), render_custom(), render_gravity_arrow(), render_system(), and System.

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_model()

void Slic3r::GUI::Bed3D::render_model ( const Transform3d & view_matrix, const Transform3d & projection_matrix )

private

{
    if (m_model_filename.empty())
        return;
 
    if (m_model.get_filename() != m_model_filename && m_model.init_from_file(m_model_filename)) {
        m_model.set_color(m_is_dark ? DEFAULT_MODEL_COLOR_DARK : DEFAULT_MODEL_COLOR);
 
        update_model_offset();
 
        // BBS: remove the bed picking logic
        //register_raycasters_for_picking(m_model.model.get_geometry(), Geometry::assemble_transform(m_model_offset));
    }
 
    if (!m_model.get_filename().empty()) {
        const Camera &     camera      = wxGetApp().plater()->get_camera();
        const Transform3d &view_matrix = camera.get_view_matrix();
        const Transform3d &projection_matrix = camera.get_projection_matrix();
        GLShaderProgram* shader = wxGetApp().get_shader("hotbed");
        if (shader != nullptr) {
            shader->start_using();
            shader->set_uniform("emission_factor", 0.0f);
            Transform3d model_matrix = Geometry::assemble_transform(m_model_offset);
            shader->set_uniform("volume_world_matrix",  model_matrix);
            shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
            shader->set_uniform("projection_matrix", projection_matrix);
            const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
            shader->set_uniform("view_normal_matrix", view_normal_matrix);
            if (m_build_volume.get_extruder_area_count() > 0) {
                const BuildVolume::BuildSharedVolume& shared_volume = m_build_volume.get_shared_volume();
                std::array<float, 4>       xy_data       = shared_volume.data;
                shader->set_uniform("print_volume.type", shared_volume.type);
                shader->set_uniform("print_volume.xy_data", xy_data);
                std::array<float, 2> zs = shared_volume.zs;
                zs[0]                   = -1;
                shader->set_uniform("print_volume.z_data", zs);
            }
            else {
                //use -1 ad a invalid type
                shader->set_uniform("print_volume.type", -1);
            }
            m_model.render();
            shader->stop_using();
        }
    }
}

References Slic3r::Geometry::assemble_transform(), Slic3r::BuildVolume::BuildSharedVolume::data, DEFAULT_MODEL_COLOR, DEFAULT_MODEL_COLOR_DARK, Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), m_build_volume, m_is_dark, m_model, m_model_filename, m_model_offset, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), Slic3r::BuildVolume::BuildSharedVolume::type, update_model_offset(), and Slic3r::BuildVolume::BuildSharedVolume::zs.

Referenced by render_custom(), and render_system().

Here is the call graph for this function:

Here is the caller graph for this function:

render_system()

void Slic3r::GUI::Bed3D::render_system ( GLCanvas3D & canvas, const Transform3d & view_matrix, const Transform3d & projection_matrix, bool bottom )

private

{
    if (!bottom)
        render_model(view_matrix, projection_matrix);
 
    /*if (show_texture)
        render_texture(bottom, canvas);*/
}

References render_model().

Referenced by render_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

set_axes_mode()

void Slic3r::GUI::Bed3D::set_axes_mode

(

bool

origin

)

{
    if (origin) {
        m_axes.set_origin({ 0.0, 0.0, static_cast<double>(GROUND_Z) });
    }
    else {
        m_axes.set_origin({ m_position.x(), m_position.y(), static_cast<double>(GROUND_Z) });
    }
}

References GROUND_Z, m_axes, and m_position.

set_axes_origin()

void Slic3r::GUI::Bed3D::set_axes_origin ( const Vec3d & origin )

inline

{ m_axes.set_origin(origin); }   // Design tab: triad at bed centre

References m_axes.

set_position()

void Slic3r::GUI::Bed3D::set_position

(

Vec2d &

position

)

{
    set_shape(m_bed_shape, m_build_volume.printable_height(), m_extruder_shapes, m_extruder_heights, m_model_filename, false, position, false);
}

References m_bed_shape, m_build_volume, m_extruder_heights, m_extruder_shapes, m_model_filename, and set_shape().

Here is the call graph for this function:

set_shape()

bool Slic3r::GUI::Bed3D::set_shape	(	const Pointfs &	printable_area,
		const double	printable_height,
		std::vector< Pointfs >	extruder_areas,
		std::vector< double >	extruder_heights,
		const std::string &	custom_model,
		bool	force_as_custom = false,
		const Vec2d	position = Vec2d::Zero(),
		bool	with_reset = true )

{
    /*auto check_texture = [](const std::string& texture) {
        boost::system::error_code ec; // so the exists call does not throw (e.g. after a permission problem)
        return !texture.empty() && (boost::algorithm::iends_with(texture, ".png") || boost::algorithm::iends_with(texture, ".svg")) && boost::filesystem::exists(texture, ec);
    };*/
 
    auto check_model = [](const std::string& model) {
        boost::system::error_code ec;
        return !model.empty() && boost::algorithm::iends_with(model, ".stl") && boost::filesystem::exists(model, ec);
    };
 
    Type type;
    std::string model;
    std::string texture;
    if (force_as_custom)
        type = Type::Custom;
    else {
        auto [new_type, system_model, system_texture] = detect_type(printable_area);
        type = new_type;
        model = system_model;
        texture = system_texture;
    }
 
    /*std::string texture_filename = custom_texture.empty() ? texture : custom_texture;
    if (! texture_filename.empty() && ! check_texture(texture_filename)) {
        BOOST_LOG_TRIVIAL(error) << "Unable to load bed texture: " << texture_filename;
        texture_filename.clear();
    }*/
 
    std::string model_filename = custom_model.empty() ? model : custom_model;
    if (! model_filename.empty() && ! check_model(model_filename)) {
        BOOST_LOG_TRIVIAL(error) << "Unable to load bed model: " << model_filename;
        model_filename.clear();
    }
 
    //BBS: add position related logic
    if (m_bed_shape == printable_area && m_build_volume.printable_height() == printable_height && m_type == type && m_model_filename == model_filename && position == m_position && m_extruder_shapes == extruder_areas  && m_extruder_heights == extruder_heights)
        // No change, no need to update the UI.
        return false;
 
    //BBS: add part plate logic, apply position to bed shape
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":current position {%1%,%2%}, new position {%3%, %4%}") % m_position.x() % m_position.y() % position.x() % position.y();
    m_position = position;
    m_bed_shape = printable_area;
    m_extruder_shapes = extruder_areas;
    m_extruder_heights = extruder_heights;
    if ((position(0) != 0) || (position(1) != 0)) {
        Pointfs new_bed_shape;
        for (const Vec2d& p : m_bed_shape) {
            Vec2d point(p(0) + m_position.x(), p(1) + m_position.y());
            new_bed_shape.push_back(point);
        }
        std::vector<Pointfs> new_extruder_shapes;
        for (const std::vector<Vec2d>& shape : m_extruder_shapes) {
            std::vector<Vec2d> new_extruder_shape;
            for (const Vec2d& p : shape) {
                Vec2d point(p(0) + m_position.x(), p(1) + m_position.y());
                new_extruder_shape.push_back(point);
            }
            new_extruder_shapes.push_back(new_extruder_shape);
        }
        m_build_volume = BuildVolume { new_bed_shape, printable_height, new_extruder_shapes, m_extruder_heights };
    }
    else
        m_build_volume = BuildVolume { printable_area, printable_height, m_extruder_shapes, m_extruder_heights };
    m_type = type;
    //m_texture_filename = texture_filename;
    m_model_filename = model_filename;
    //BBS add default bed
    m_triangles.reset();
    if (with_reset) {
        //m_texture.reset();
        m_model.reset();
    }
    //BBS: add part plate logic, always update model offset
    update_model_offset();//include m_extended_bounding_box = this->calc_extended_bounding_box();
 
    // Set the origin and size for rendering the coordinate system axes.
    m_axes.set_origin({ 0.0, 0.0, static_cast<double>(GROUND_Z) });
    m_axes.set_stem_length(0.1f * static_cast<float>(m_build_volume.bounding_volume().max_size()));
 
    // unregister from picking
    // BBS: remove the bed picking logic
    // wxGetApp().plater()->canvas3D()->remove_raycasters_for_picking(SceneRaycaster::EType::Bed);
 
    // Let the calee to update the UI.
    return true;
}

References Custom, detect_type(), GROUND_Z, m_axes, m_bed_shape, m_build_volume, m_extruder_heights, m_extruder_shapes, m_model, m_model_filename, m_position, m_triangles, m_type, Slic3r::GUI::model_filename, Slic3r::printable_area(), Slic3r::printable_height(), and update_model_offset().

Referenced by set_position().

Here is the call graph for this function:

Here is the caller graph for this function:

update_bed_triangles()

void Slic3r::GUI::Bed3D::update_bed_triangles ( )

private

{
    if (m_triangles.is_initialized()) {
        return;
    }
 
    Vec3d shift = m_extended_bounding_box.center();
    shift(2) = -0.03;
    Vec3d* model_offset_ptr = const_cast<Vec3d*>(&m_model_offset);
    *model_offset_ptr = shift;
    //BBS: TODO: hack for default bed
    BoundingBoxf3 build_volume;
 
    if (!m_build_volume.valid()) return;
    auto bed_ext = get_extents(m_bed_shape);
    (*model_offset_ptr)(0) = m_build_volume.bounding_volume2d().min.x() - bed_ext.min.x();
    (*model_offset_ptr)(1) = m_build_volume.bounding_volume2d().min.y() - bed_ext.min.y();
    (*model_offset_ptr)(2) = -0.41 + GROUND_Z;
 
    std::vector<Vec2d> origin_bed_shape;
    for (size_t i = 0; i < m_bed_shape.size(); i++) {
         origin_bed_shape.push_back(m_bed_shape[i]);
    }
    std::vector<Vec2d> new_bed_shape; // offset to correct origin
    for (auto point : origin_bed_shape) {
        Vec2d new_point(point.x() + model_offset_ptr->x(), point.y() + model_offset_ptr->y());
        new_bed_shape.push_back(new_point);
    }
    ExPolygon poly{ Polygon::new_scale(new_bed_shape) };
    if (!init_model_from_poly(m_triangles, poly, GROUND_Z)) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":Unable to update plate triangles\n";
    }
    // update extended bounding box
    const_cast<BoundingBoxf3 &>(m_printable_bounding_box) = calc_printable_bounding_box();
    const_cast<BoundingBoxf3 &>(m_extended_bounding_box)  = calc_extended_bounding_box();
}

References build_volume(), calc_extended_bounding_box(), calc_printable_bounding_box(), Slic3r::get_extents(), GROUND_Z, Slic3r::GUI::init_model_from_poly(), m_bed_shape, m_build_volume, m_extended_bounding_box, m_model_offset, m_printable_bounding_box, m_triangles, and Slic3r::Polygon::new_scale().

Referenced by render_default().

Here is the call graph for this function:

Here is the caller graph for this function:

update_model_offset()

void Slic3r::GUI::Bed3D::update_model_offset ( )

private

{
    // move the model so that its origin (0.0, 0.0, 0.0) goes into the bed shape center and a bit down to avoid z-fighting with the texture quad
    Vec3d shift = m_build_volume.bounding_volume().center();
    shift(2) = -0.03;
    Vec3d* model_offset_ptr = const_cast<Vec3d*>(&m_model_offset);
    *model_offset_ptr = shift;
    //BBS: TODO: hack for current stl for BBL printer
    if (std::string::npos != m_model_filename.find("bbl-3dp-"))
    {
        (*model_offset_ptr)(0) -= m_bed_shape[2].x() / 2.0f;
        (*model_offset_ptr)(1) -= m_bed_shape[2].y() / 2.0f;
    }
    (*model_offset_ptr)(2) = -0.41 + GROUND_Z;
 
    // update extended bounding box
    const_cast<BoundingBoxf3 &>(m_printable_bounding_box) = calc_printable_bounding_box();
    const_cast<BoundingBoxf3 &>(m_extended_bounding_box)  = calc_extended_bounding_box();
    m_triangles.reset();
}

References calc_extended_bounding_box(), calc_printable_bounding_box(), GROUND_Z, m_bed_shape, m_build_volume, m_extended_bounding_box, m_model_filename, m_model_offset, m_printable_bounding_box, and m_triangles.

Referenced by render_model(), and set_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

update_render_colors()

void Slic3r::GUI::Bed3D::update_render_colors ( )

static

{
    Bed3D::AXIS_X_COLOR = ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Axis_X]);
    Bed3D::AXIS_Y_COLOR = ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Axis_Y]);
    Bed3D::AXIS_Z_COLOR = ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_Axis_Z]);
}

References AXIS_X_COLOR, AXIS_Y_COLOR, AXIS_Z_COLOR, Slic3r::RenderColor::colors, Slic3r::GUI::ImGuiWrapper::from_ImVec4(), RenderCol_Axis_X, RenderCol_Axis_Y, and RenderCol_Axis_Z.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

AXIS_X_COLOR

ColorRGBA Slic3r::GUI::Bed3D::AXIS_X_COLOR = ColorRGBA::X()

static

Referenced by load_render_colors(), Slic3r::GUI::Bed3D::Axes::render(), and update_render_colors().

AXIS_Y_COLOR

ColorRGBA Slic3r::GUI::Bed3D::AXIS_Y_COLOR = ColorRGBA::Y()

static

Referenced by load_render_colors(), Slic3r::GUI::Bed3D::Axes::render(), and update_render_colors().

AXIS_Z_COLOR

ColorRGBA Slic3r::GUI::Bed3D::AXIS_Z_COLOR = ColorRGBA::Z()

static

Referenced by load_render_colors(), Slic3r::GUI::Bed3D::Axes::render(), and update_render_colors().

DEFAULT_MODEL_COLOR

ColorRGBA Slic3r::GUI::Bed3D::DEFAULT_MODEL_COLOR = { 0.3255f, 0.337f, 0.337f, 1.0f }

static

Referenced by render_default(), render_internal(), render_model(), and Slic3r::GUI::Bed_2D::repaint().

DEFAULT_MODEL_COLOR_DARK

ColorRGBA Slic3r::GUI::Bed3D::DEFAULT_MODEL_COLOR_DARK = { 0.255f, 0.255f, 0.283f, 1.0f }

static

Referenced by render_default(), render_internal(), render_model(), and Slic3r::GUI::Bed_2D::repaint().

DEFAULT_SOLID_GRID_COLOR

ColorRGBA Slic3r::GUI::Bed3D::DEFAULT_SOLID_GRID_COLOR = { 0.9f, 0.9f, 0.9f, 1.0f }

static

DEFAULT_TRANSPARENT_GRID_COLOR

ColorRGBA Slic3r::GUI::Bed3D::DEFAULT_TRANSPARENT_GRID_COLOR = { 0.9f, 0.9f, 0.9f, 0.6f }

static

m_axes

Axes Slic3r::GUI::Bed3D::m_axes

private

Referenced by calc_printable_bounding_box(), render_axes(), render_gravity_arrow(), set_axes_mode(), set_axes_origin(), and set_shape().

m_bed_shape

std::vector<Vec2d> Slic3r::GUI::Bed3D::m_bed_shape

private

Referenced by set_position(), set_shape(), update_bed_triangles(), and update_model_offset().

m_build_volume

BuildVolume Slic3r::GUI::Bed3D::m_build_volume

private

Referenced by build_volume(), build_volume(), calc_printable_bounding_box(), get_build_volume_type(), render_axes(), render_model(), set_position(), set_shape(), update_bed_triangles(), and update_model_offset().

m_extended_bounding_box

BoundingBoxf3 Slic3r::GUI::Bed3D::m_extended_bounding_box

private

Referenced by extended_bounding_box(), update_bed_triangles(), and update_model_offset().

m_extruder_heights

std::vector<double> Slic3r::GUI::Bed3D::m_extruder_heights

private

Referenced by set_position(), and set_shape().

m_extruder_shapes

std::vector<std::vector<Vec2d> > Slic3r::GUI::Bed3D::m_extruder_shapes

private

Referenced by set_position(), and set_shape().

m_gravity_arrow

GLModel Slic3r::GUI::Bed3D::m_gravity_arrow

private

Referenced by render_gravity_arrow().

m_gravity_arrow_length

float Slic3r::GUI::Bed3D::m_gravity_arrow_length { 0.f }

private

{ 0.f };

Referenced by render_gravity_arrow().

m_is_dark

bool Slic3r::GUI::Bed3D::m_is_dark = false

private

Referenced by on_change_color_mode(), render_default(), render_internal(), and render_model().

m_model

GLModel Slic3r::GUI::Bed3D::m_model

private

Referenced by calc_extended_bounding_box(), render_default(), render_internal(), render_model(), and set_shape().

m_model_filename

std::string Slic3r::GUI::Bed3D::m_model_filename

private

Referenced by render_custom(), render_model(), set_position(), set_shape(), and update_model_offset().

m_model_offset

Vec3d Slic3r::GUI::Bed3D::m_model_offset { Vec3d::Zero() }

private

{ Vec3d::Zero() };

Referenced by calc_extended_bounding_box(), render_model(), update_bed_triangles(), and update_model_offset().

m_position

Vec2d Slic3r::GUI::Bed3D::m_position { Vec2d::Zero() }

private

{ Vec2d::Zero() };

Referenced by calc_printable_bounding_box(), get_position(), set_axes_mode(), and set_shape().

m_printable_bounding_box

BoundingBoxf3 Slic3r::GUI::Bed3D::m_printable_bounding_box

private

Referenced by calc_extended_bounding_box(), printable_bounding_box(), update_bed_triangles(), and update_model_offset().

m_scale_factor

float Slic3r::GUI::Bed3D::m_scale_factor { 1.0f }

private

{ 1.0f };

Referenced by render_internal().

m_triangles

GLModel Slic3r::GUI::Bed3D::m_triangles

private

Referenced by render_default(), set_shape(), update_bed_triangles(), and update_model_offset().

m_type

Type Slic3r::GUI::Bed3D::m_type { Type::System }

private

{ Type::System };

Referenced by get_type(), is_custom(), render_internal(), and set_shape().

---

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

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