Slic3r::GUI::GLCanvas3D::Labels Class Reference

Collaboration diagram for Slic3r::GUI::GLCanvas3D::Labels:

Public Member Functions
	Labels (GLCanvas3D &canvas)
void	enable (bool enable)
void	show (bool show)
bool	is_shown () const
void	render (const std::vector< const ModelInstance * > &sorted_instances) const

Private Attributes
bool	m_enabled { false }
bool	m_shown { false }
GLCanvas3D &	m_canvas

Detailed Description

Constructor & Destructor Documentation

Labels()

Slic3r::GUI::GLCanvas3D::Labels::Labels ( GLCanvas3D & canvas )

inlineexplicit

: m_canvas(canvas) {}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), and m_canvas.

Here is the call graph for this function:

Member Function Documentation

enable()

void Slic3r::GUI::GLCanvas3D::Labels::enable ( bool enable )

inline

{ m_enabled = enable; }

References enable(), and m_enabled.

Referenced by enable().

Here is the call graph for this function:

Here is the caller graph for this function:

is_shown()

bool Slic3r::GUI::GLCanvas3D::Labels::is_shown ( ) const

inline

{ return m_shown; }

References m_shown.

Referenced by render().

Here is the caller graph for this function:

render()

void Slic3r::GUI::GLCanvas3D::Labels::render

(

const std::vector< const ModelInstance * > &

sorted_instances

)

const

{
    if (!m_enabled || !is_shown() || m_canvas.get_gizmos_manager().is_running())
        return;
 
    const Camera& camera = wxGetApp().plater()->get_camera();
    const Model* model = m_canvas.get_model();
    if (model == nullptr)
        return;
 
    Transform3d world_to_eye = camera.get_view_matrix();
    Transform3d world_to_screen = camera.get_projection_matrix() * world_to_eye;
    const std::array<int, 4>& viewport = camera.get_viewport();
 
    struct Owner
    {
        int obj_idx;
        int inst_idx;
        size_t model_instance_id;
        BoundingBoxf3 world_box;
        double eye_center_z;
        std::string title;
        std::string label;
        std::string print_order;
        bool selected;
    };
 
    // collect owners world bounding boxes and data from volumes
    std::vector<Owner> owners;
    const GLVolumeCollection& volumes = m_canvas.get_volumes();
    PartPlate* cur_plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
    for (const GLVolume* volume : volumes.volumes) {
        int obj_idx = volume->object_idx();
        if (0 <= obj_idx && obj_idx < (int)model->objects.size()) {
            int inst_idx = volume->instance_idx();
            //only show current plate's label
            if (!cur_plate->contain_instance(obj_idx, inst_idx))
                continue;
            std::vector<Owner>::iterator it = std::find_if(owners.begin(), owners.end(), [obj_idx, inst_idx](const Owner& owner) {
                return (owner.obj_idx == obj_idx) && (owner.inst_idx == inst_idx);
                });
            if (it != owners.end()) {
                it->world_box.merge(volume->transformed_bounding_box());
                it->selected &= volume->selected;
            } else {
                const ModelObject* model_object = model->objects[obj_idx];
                Owner owner;
                owner.obj_idx = obj_idx;
                owner.inst_idx = inst_idx;
                owner.model_instance_id = model_object->instances[inst_idx]->id().id;
                owner.world_box = volume->transformed_bounding_box();
                owner.title = "object" + std::to_string(obj_idx) + "_inst##" + std::to_string(inst_idx);
                owner.label = model_object->name;
                if (model_object->instances.size() > 1)
                    owner.label += " (" + std::to_string(inst_idx + 1) + ")";
                owner.selected = volume->selected;
                owners.emplace_back(owner);
            }
        }
    }
 
    // updates print order strings
    if (sorted_instances.size() > 0) {
        for (size_t i = 0; i < sorted_instances.size(); ++i) {
            size_t id = sorted_instances[i]->id().id;
            std::vector<Owner>::iterator it = std::find_if(owners.begin(), owners.end(), [id](const Owner& owner) {
                return owner.model_instance_id == id;
                });
            if (it != owners.end())
                //it->print_order = std::string((_(L("Sequence"))).ToUTF8()) + "#: " + std::to_string(i + 1);
                it->print_order = std::string((_(L("Sequence"))).ToUTF8()) + "#: " + std::to_string(sorted_instances[i]->arrange_order);
        }
    }
 
    // calculate eye bounding boxes center zs
    for (Owner& owner : owners) {
        owner.eye_center_z = (world_to_eye * owner.world_box.center())(2);
    }
 
    // sort owners by center eye zs and selection
    std::sort(owners.begin(), owners.end(), [](const Owner& owner1, const Owner& owner2) {
        if (!owner1.selected && owner2.selected)
            return true;
        else if (owner1.selected && !owner2.selected)
            return false;
        else
            return (owner1.eye_center_z < owner2.eye_center_z);
        });
 
    ImGuiWrapper& imgui = *wxGetApp().imgui();
 
    // render info windows
    for (const Owner& owner : owners) {
        Vec3d screen_box_center = world_to_screen * owner.world_box.center();
        float x = 0.0f;
        float y = 0.0f;
        if (camera.get_type() == Camera::EType::Perspective) {
            x = (0.5f + 0.001f * 0.5f * (float)screen_box_center(0)) * viewport[2];
            y = (0.5f - 0.001f * 0.5f * (float)screen_box_center(1)) * viewport[3];
        } else {
            x = (0.5f + 0.5f * (float)screen_box_center(0)) * viewport[2];
            y = (0.5f - 0.5f * (float)screen_box_center(1)) * viewport[3];
        }
 
        if (x < 0.0f || viewport[2] < x || y < 0.0f || viewport[3] < y)
            continue;
 
        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, owner.selected ? 3.0f : 1.5f);
        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
        ImGui::PushStyleColor(ImGuiCol_Border, owner.selected ? ImVec4(0.757f, 0.404f, 0.216f, 1.0f) : ImVec4(0.75f, 0.75f, 0.75f, 1.0f));
        imgui.set_next_window_pos(x, y, ImGuiCond_Always, 0.5f, 0.5f);
        imgui.begin(owner.title, ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove);
        ImGui::BringWindowToDisplayFront(ImGui::GetCurrentWindow());
        float win_w = ImGui::GetWindowWidth();
        ImGui::AlignTextToFramePadding();
        imgui.text(owner.label);
 
        if (!owner.print_order.empty()) {
            ImGui::Separator();
            float po_len = imgui.calc_text_size(owner.print_order).x;
            ImGui::SetCursorPosX(0.5f * (win_w - po_len));
            ImGui::AlignTextToFramePadding();
            imgui.text(owner.print_order);
        }
 
        // force re-render while the windows gets to its final size (it takes several frames)
        if (ImGui::GetWindowContentRegionWidth() + 2.0f * ImGui::GetStyle().WindowPadding.x != ImGui::CalcWindowNextAutoFitSize(ImGui::GetCurrentWindow()).x)
            imgui.set_requires_extra_frame();
 
        imgui.end();
        ImGui::PopStyleColor();
        ImGui::PopStyleVar(2);
    }
}

References _, Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::ImGuiWrapper::calc_text_size(), Slic3r::GUI::GLCanvas3D::camera, Slic3r::GUI::PartPlate::contain_instance(), Slic3r::GUI::ImGuiWrapper::end(), Slic3r::GLVolume::instance_idx(), Slic3r::ModelObject::instances, is_shown(), L, m_canvas, m_enabled, Slic3r::ModelObject::name, Slic3r::GLVolume::object_idx(), Slic3r::Model::objects, Slic3r::GUI::Camera::Perspective, render(), Slic3r::GUI::ImGuiWrapper::set_next_window_pos(), Slic3r::GUI::ImGuiWrapper::set_requires_extra_frame(), Slic3r::GUI::ImGuiWrapper::text(), Slic3r::GLVolume::transformed_bounding_box(), and Slic3r::GLVolumeCollection::volumes.

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

show()

void Slic3r::GUI::GLCanvas3D::Labels::show ( bool show )

inline

{ m_shown = m_enabled ? show : false; }

References m_enabled, m_shown, and show().

Referenced by show().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_canvas

GLCanvas3D& Slic3r::GUI::GLCanvas3D::Labels::m_canvas

private

Referenced by Labels(), and render().

m_enabled

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

private

{ false };

Referenced by enable(), render(), and show().

m_shown

bool Slic3r::GUI::GLCanvas3D::Labels::m_shown { false }

private

{ false };

Referenced by is_shown(), and show().

---

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