Slic3r::GUI::GLCanvas3D::CenterOfMass Class Reference

Collaboration diagram for Slic3r::GUI::GLCanvas3D::CenterOfMass:

Classes
struct	Marker
struct	Bodies
struct	Pick

Public Member Functions
void	render (GLCanvas3D &canvas)
bool	on_left_down (GLCanvas3D &canvas, const Vec2d &mouse)
void	render_details (GLCanvas3D &canvas)

Private Types
enum	MarkerKind : size_t {   mkPlate , mkObject , mkSupport , mkBody ,   mkCount }
using	Sum = GCodeProcessorResult::ObjectMass::Sum
using	Markers = std::array<std::vector<Marker>, mkCount>

Private Member Functions
Markers	model_markers (const GLCanvas3D &canvas)

Private Attributes
std::array< GLModel, 2 >	m_octants
std::map< size_t, MassProperties >	m_meshes
std::map< size_t, Bodies >	m_bodies
std::array< Markers, 2 >	m_drawn
size_t	m_top_layer { 0 }
std::optional< Pick >	m_picked

Detailed Description

---

Class Documentation

Slic3r::GUI::GLCanvas3D::CenterOfMass::Bodies

struct Slic3r::GUI::GLCanvas3D::CenterOfMass::Bodies

Collaboration diagram for Slic3r::GUI::GLCanvas3D::CenterOfMass::Bodies:

Class Members
vector< SolidBody >	bodies
size_t	slabs { 0 }
vector< Volume >	volumes

Slic3r::GUI::GLCanvas3D::CenterOfMass::Pick

struct Slic3r::GUI::GLCanvas3D::CenterOfMass::Pick

Class Members
size_t	count
size_t	index
size_t	kind
size_t	set

Member Typedef Documentation

Markers

using Slic3r::GUI::GLCanvas3D::CenterOfMass::Markers = std::array<std::vector<Marker>, mkCount>

private

Sum

using Slic3r::GUI::GLCanvas3D::CenterOfMass::Sum = GCodeProcessorResult::ObjectMass::Sum

private

Member Enumeration Documentation

MarkerKind

enum Slic3r::GUI::GLCanvas3D::CenterOfMass::MarkerKind : size_t

private

Enumerator
mkPlate
mkObject
mkSupport
mkBody
mkCount

: size_t { mkPlate, mkObject, mkSupport, mkBody, mkCount };

Member Function Documentation

model_markers()

GLCanvas3D::CenterOfMass::Markers Slic3r::GUI::GLCanvas3D::CenterOfMass::model_markers ( const GLCanvas3D & canvas )

private

{
    Markers markers;
    if (canvas.get_model() == nullptr)
        return markers;
 
    struct Instance
    {
        Transform3d                   trafo;
        std::vector<const GLVolume*> volumes;
    };
    std::map<int, std::map<int, Instance>> objects;
    const ModelObjectPtrs&                 model_objects = canvas.get_model()->objects;
    for (const GLVolume* volume : canvas.get_volumes().volumes) {
        const int obj_idx = volume->object_idx();
        const int vol_idx = volume->volume_idx();
        if (!volume->is_active || volume->is_wipe_tower || obj_idx < 0 || obj_idx >= int(model_objects.size()) || vol_idx < 0 ||
            vol_idx >= int(model_objects[obj_idx]->volumes.size()))
            continue;
        Instance& instance = objects[obj_idx][volume->instance_idx()];
        instance.trafo     = volume->get_instance_transformation().get_matrix();
        instance.volumes.emplace_back(volume);
    }
 
    // From the filament presets, as the plater config holds the values of the last filament edited only.
    const PresetBundle& preset_bundle = *wxGetApp().preset_bundle;
    std::vector<double> filament_densities;
    for (const std::string& name : preset_bundle.filament_presets)
        filament_densities.emplace_back(preset_bundle.filaments.find_preset(name, true)->config.opt_float("filament_density", 0));
    const auto density = [&filament_densities](const ModelVolume& volume) {
        const size_t filament = size_t(std::max(1, volume.extruder_id()));
        const double density  = filament <= filament_densities.size() ? filament_densities[filament - 1] : 0.;
        return density > 0. ? density : double(DEFAULT_FILAMENT_DENSITY);
    };
 
    // One per plate, of the instances on it.
    PartPlateList&                   plate_list = wxGetApp().plater()->get_partplate_list();
    std::map<int, Marker>            plates;
    std::map<size_t, MassProperties> meshes;
    std::map<size_t, Bodies>         bodies;
    for (const auto& [obj_idx, instances] : objects) {
        const ModelObject& object = *model_objects[obj_idx];
        // An assembly is sliced, so that its overlapping parts are united and its negative volumes cut away, in the
        // order of its volumes, as the later one prints where two overlap.
        std::vector<const GLVolume*> volumes = instances.begin()->second.volumes;
        std::sort(volumes.begin(), volumes.end(), [](const GLVolume* l, const GLVolume* r) { return l->volume_idx() < r->volume_idx(); });
        std::vector<MeshInPlace>    solids;
        std::vector<double>         densities;
        std::vector<MeshInPlace>    negatives;
        std::vector<Bodies::Volume> sliced;
        for (const GLVolume* volume : volumes) {
            const ModelVolume& model_volume = *object.volumes[volume->volume_idx()];
            if (!model_volume.is_model_part() && !model_volume.is_negative_volume())
                continue;
            const Transform3d trafo = volume->get_volume_transformation().get_matrix();
            if (model_volume.is_model_part()) {
                solids.emplace_back(&model_volume.mesh().its, trafo);
                densities.emplace_back(density(model_volume));
            } else
                negatives.emplace_back(&model_volume.mesh().its, trafo);
            sliced.push_back({ model_volume.id().id, model_volume.is_negative_volume(), model_volume.is_model_part() ? densities.back() : 0., trafo });
        }
        const std::vector<SolidBody>* assembly = nullptr;
        if (solids.size() > 1 || (!solids.empty() && !negatives.empty())) {
            // Coarser while a part is dragged.
            const size_t slabs  = canvas.is_dragging() ? 100 : 500;
            const auto   cached = m_bodies.find(object.id().id);
            const bool   valid  = cached != m_bodies.end() && cached->second.slabs >= slabs && cached->second.volumes == sliced;
            Bodies& entry = bodies[object.id().id];
            entry = valid ? std::move(cached->second) : Bodies{ std::move(sliced), slabs, solid_bodies(solids, densities, negatives, slabs) };
            assembly      = &entry.bodies;
        }
 
        for (const auto& [inst_idx, instance] : instances) {
            // The box of its parts, which the object's size shows.
            Marker object_marker;
            object_marker.assembly = assembly != nullptr;
            for (const GLVolume* volume : instance.volumes)
                if (object.volumes[volume->volume_idx()]->is_model_part())
                    object_marker.box.merge(volume->transformed_convex_hull_bounding_box());
            if (assembly != nullptr) {
                std::vector<Marker> parts;
                for (const SolidBody& body : *assembly)
                    if (body.mass > 0.) {
                        parts.push_back({ mass_sum(body.transformed(instance.trafo)), body.bounding_box(instance.trafo) });
                        object_marker.sum.add(parts.back().sum);
                    }
                if (parts.size() > 1)
                    append(markers[mkBody], std::move(parts));
            } else
                for (const GLVolume* volume : instance.volumes) {
                    // The parts the object info's volume sums.
                    const ModelVolume& model_volume = *object.volumes[volume->volume_idx()];
                    if (!model_volume.is_model_part())
                        continue;
                    const auto [it, inserted] = meshes.try_emplace(model_volume.id().id);
                    if (inserted) {
                        const auto cached = m_meshes.find(it->first);
                        it->second = cached != m_meshes.end() ? cached->second : its_mass_properties(model_volume.mesh().its);
                    }
                    MassProperties part = it->second.transformed(volume->world_matrix());
                    part.mass *= density(model_volume);
                    object_marker.sum.add(mass_sum(part));
                }
            if (object_marker.sum.mass > 0.) {
                if (const int plate = plate_list.find_instance(obj_idx, inst_idx); plate >= 0) {
                    plates[plate].sum.add(object_marker.sum);
                    plates[plate].box.merge(object_marker.box);
                }
                markers[mkObject].emplace_back(std::move(object_marker));
            }
        }
    }
    m_meshes = std::move(meshes);
    m_bodies = std::move(bodies);
    for (auto& [plate, marker] : plates)
        markers[mkPlate].emplace_back(std::move(marker));
    return markers;
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), Slic3r::GCodeProcessorResult::ObjectMass::Sum::add(), Slic3r::append(), Slic3r::GUI::GLCanvas3D::CenterOfMass::Marker::assembly, Slic3r::GUI::GLCanvas3D::CenterOfMass::Bodies::bodies, Slic3r::GUI::GLCanvas3D::CenterOfMass::Marker::box, Slic3r::Preset::config, Slic3r::DEFAULT_FILAMENT_DENSITY, Slic3r::PresetBundle::filament_presets, Slic3r::PresetBundle::filaments, Slic3r::GUI::PartPlateList::find_instance(), Slic3r::PresetCollection::find_preset(), Slic3r::GUI::GLCanvas3D::get_model(), Slic3r::GUI::GLCanvas3D::get_volumes(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::GUI::Instance, Slic3r::GUI::GLCanvas3D::is_dragging(), Slic3r::ModelVolume::is_model_part(), Slic3r::ModelVolume::is_negative_volume(), Slic3r::TriangleMesh::its, Slic3r::its_mass_properties(), m_bodies, m_meshes, Slic3r::GCodeProcessorResult::ObjectMass::Sum::mass, Slic3r::MassProperties::mass, Slic3r::GUI::mass_sum(), Slic3r::BoundingBox3Base< PointType >::merge(), Slic3r::ModelVolume::mesh(), mkBody, mkObject, mkPlate, model_markers(), Slic3r::Model::objects, Slic3r::DynamicConfig::opt_float(), Slic3r::solid_bodies(), Slic3r::GUI::GLCanvas3D::CenterOfMass::Marker::sum, Slic3r::MassProperties::transformed(), Slic3r::GLVolume::transformed_convex_hull_bounding_box(), Slic3r::GLVolume::volume_idx(), Slic3r::GLVolumeCollection::volumes, and Slic3r::GLVolume::world_matrix().

Referenced by model_markers(), and render().

Here is the call graph for this function:

Here is the caller graph for this function:

on_left_down()

bool Slic3r::GUI::GLCanvas3D::CenterOfMass::on_left_down	(	GLCanvas3D &	canvas,
		const Vec2d &	mouse )

{
    const bool    shown  = m_picked.has_value();
    const Camera& camera = wxGetApp().plater()->get_camera();
    const double  scale  = marker_scale(canvas) * camera.get_inv_zoom();
    m_picked.reset();
    // In the order they cover each other: what is printed so far over the finished print, smaller kinds over larger ones.
    for (size_t set = m_drawn.size(); set-- > 0 && !m_picked;)
        for (size_t kind = mkCount; kind-- > 0 && !m_picked;)
            for (size_t index = 0; index < m_drawn[set][kind].size(); ++index) {
                const Vec3d              center = m_drawn[set][kind][index].center();
                const std::vector<Vec3d> ends   = { center, center + marker_radii[kind] * scale * camera.get_dir_right() };
                const Points             screen = CameraUtils::project(camera, ends);
                if ((screen[0].cast<double>() - mouse).norm() <= (screen[1] - screen[0]).cast<double>().norm()) {
                    m_picked = Pick{ set, kind, index, m_drawn[set][kind].size() };
                    break;
                }
            }
    if (shown || m_picked)
        canvas._set_overlay_as_dirty();
    return m_picked.has_value();
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), Slic3r::GUI::GLCanvas3D::_set_overlay_as_dirty(), Slic3r::GUI::GLCanvas3D::camera, Slic3r::cast(), Slic3r::center(), m_drawn, m_picked, Slic3r::GUI::marker_radii, Slic3r::GUI::marker_scale(), mkCount, on_left_down(), Slic3r::GUI::CameraUtils::project(), and scale().

Referenced by on_left_down().

Here is the call graph for this function:

Here is the caller graph for this function:

render()

void Slic3r::GUI::GLCanvas3D::CenterOfMass::render

(

GLCanvas3D &

canvas

)

{
    m_drawn = {};
    const bool preview = canvas.m_canvas_type == ECanvasType::CanvasPreview;
    // The other gizmos work on the surface the marker would cover.
    const GLGizmosManager::EType gizmo = canvas.get_gizmos_manager().get_current_type();
    if (!wxGetApp().show_center_of_mass() || canvas.m_design_canvas ||
        !(canvas.m_canvas_type == ECanvasType::CanvasView3D || (preview && canvas.m_render_preview)) ||
        (gizmo != GLGizmosManager::Undefined && gizmo != GLGizmosManager::Move && gizmo != GLGizmosManager::Rotate &&
         gizmo != GLGizmosManager::Scale && gizmo != GLGizmosManager::Flatten))
        return;
    GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
    if (shader == nullptr)
        return;
 
    // Preview adds markers for what is printed up to the top layer shown.
    if (preview) {
        const GCodeViewer& gcode_viewer = canvas.get_gcode_viewer();
        m_top_layer                     = gcode_viewer.get_layers_z_range()[1];
        const auto add = [this](const GCodeProcessorResult::ObjectMass& mass, MarkerKind kind) {
            if (const Sum total = mass.total(); total.mass > 0.)
                m_drawn[0][kind].push_back({ total, mass.box, mass.assembly });
            if (!mass.printed_up_to_layer.empty())
                if (const Sum& sum = mass.printed_up_to_layer[std::min(m_top_layer, mass.printed_up_to_layer.size() - 1)]; sum.mass > 0.)
                    m_drawn[1][kind].push_back({ sum, mass.box, mass.assembly });
        };
        add(gcode_viewer.get_plate_mass(), mkPlate);
        for (const GCodeProcessorResult::ObjectMass& object : gcode_viewer.get_object_masses())
            add(object, mkObject);
        for (const GCodeProcessorResult::ObjectMass& body : gcode_viewer.get_body_masses())
            add(body, mkBody);
        for (const GCodeProcessorResult::ObjectMass& support : gcode_viewer.get_support_masses())
            add(support, mkSupport);
    } else
        m_drawn[0] = model_markers(canvas);
    if (std::all_of(m_drawn.begin(), m_drawn.end(),
                    [](const Markers& markers) { return std::all_of(markers.begin(), markers.end(), [](const auto& kind) { return kind.empty(); }); }))
        return;
 
    if (!m_octants[0].is_initialized()) {
        // A resolution divisible by 4 puts every triangle within one octant.
        const GLModel::Geometry          sphere = smooth_sphere(32, 1.f);
        std::array<GLModel::Geometry, 2> octants;
        for (size_t i = 0; i + 2 < sphere.indices_count(); i += 3) {
            const std::array<unsigned int, 3> ids = { sphere.extract_index(i), sphere.extract_index(i + 1), sphere.extract_index(i + 2) };
            const Vec3f c = sphere.extract_position_3(ids[0]) + sphere.extract_position_3(ids[1]) + sphere.extract_position_3(ids[2]);
            GLModel::Geometry& octant = octants[c.x() * c.y() * c.z() > 0.f ? 0 : 1];
            for (const unsigned int id : ids)
                octant.add_vertex(sphere.extract_position_3(id), sphere.extract_normal_3(id));
            const auto n = (unsigned int)octant.vertices_count();
            octant.add_triangle(n - 3, n - 2, n - 1);
        }
        for (size_t i = 0; i < octants.size(); ++i)
            m_octants[i].init_from(std::move(octants[i]));
    }
 
    const Camera&      camera      = wxGetApp().plater()->get_camera();
    const Transform3d& view_matrix = camera.get_view_matrix();
    const double       scale       = marker_scale(canvas) * camera.get_inv_zoom();
 
    // Seen through the object it lies in; culling keeps the sphere's far half behind its near one.
    glsafe(::glDisable(GL_DEPTH_TEST));
    glsafe(::glEnable(GL_CULL_FACE));
    shader->start_using();
    shader->set_uniform("projection_matrix", camera.get_projection_matrix());
    shader->set_uniform("view_normal_matrix", (Matrix3d)view_matrix.matrix().block(0, 0, 3, 3));
    shader->set_uniform("emission_factor", 0.1f);
    const std::array<std::array<ColorRGBA, 2>, mkCount> colors = { {
        { ColorRGBA(0.1f, 0.1f, 0.1f, 1.f), ColorRGBA::WHITE() },
        { ColorRGBA(0x5A / 255.f, 0x9B / 255.f, 0xD4 / 255.f, 1.f), ColorRGBA::WHITE() },
        { ColorRGBA(0.f, 0.6f, 0.f, 1.f), ColorRGBA(0.1f, 0.1f, 0.1f, 1.f) },
        { ColorRGBA(0.7f, 0.f, 0.f, 1.f), ColorRGBA::YELLOW() },
    } };
    const auto draw = [&](const Markers& markers, float alpha) {
        for (size_t kind = 0; kind < mkCount; ++kind)
            for (const Marker& marker : markers[kind]) {
                shader->set_uniform("view_model_matrix", view_matrix * Geometry::translation_transform(marker.center()) *
                                                             Geometry::scale_transform(marker_radii[kind] * scale));
                for (size_t i = 0; i < m_octants.size(); ++i) {
                    ColorRGBA color = colors[kind][i];
                    color.a(alpha);
                    m_octants[i].set_color(color);
                    m_octants[i].render();
                }
            }
    };
    // Preview fades the finished parts' markers under those of what is printed so far.
    draw(m_drawn[0], preview ? 0.4f : 1.f);
    draw(m_drawn[1], 1.f);
    shader->stop_using();
    glsafe(::glEnable(GL_DEPTH_TEST));
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), Slic3r::GCodeProcessorResult::ObjectMass::assembly, Slic3r::GCodeProcessorResult::ObjectMass::box, Slic3r::GUI::GLCanvas3D::CanvasPreview, Slic3r::GUI::GLCanvas3D::CanvasView3D, Slic3r::GUI::GLGizmosManager::Flatten, Slic3r::GUI::GCodeViewer::get_body_masses(), Slic3r::GUI::GLGizmosManager::get_current_type(), Slic3r::GUI::GLCanvas3D::get_gcode_viewer(), Slic3r::GUI::GLCanvas3D::get_gizmos_manager(), Slic3r::GUI::GCodeViewer::get_layers_z_range(), Slic3r::GUI::GCodeViewer::get_object_masses(), Slic3r::GUI::GCodeViewer::get_plate_mass(), Slic3r::GUI::GCodeViewer::get_support_masses(), Slic3r::GUI::GLCanvas3D::m_canvas_type, Slic3r::GUI::GLCanvas3D::m_design_canvas, m_drawn, Slic3r::GUI::GLCanvas3D::m_render_preview, m_top_layer, Slic3r::GCodeProcessorResult::ObjectMass::Sum::mass, mkBody, mkObject, mkPlate, mkSupport, model_markers(), Slic3r::GUI::GLGizmosManager::Move, Slic3r::GCodeProcessorResult::ObjectMass::printed_up_to_layer, render(), Slic3r::GUI::GLGizmosManager::Rotate, Slic3r::GUI::GLGizmosManager::Scale, Slic3r::GCodeProcessorResult::ObjectMass::total(), and Slic3r::GUI::GLGizmosManager::Undefined.

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_details()

void Slic3r::GUI::GLCanvas3D::CenterOfMass::render_details

(

GLCanvas3D &

canvas

)

{
    if (!m_picked)
        return;
    const Pick&                pick    = *m_picked;
    const std::vector<Marker>& markers = m_drawn[pick.set][pick.kind];
    // Gone with the markers, or with what it stood for.
    if (markers.size() != pick.count) {
        m_picked.reset();
        return;
    }
    const Marker& marker = markers[pick.index];
    const Sum&    sum    = marker.sum;
    const Vec3d   center = marker.center();
    // About the axes through the center, from how far the mass spreads along the two others.
    const Vec3d spread  = (sum.second / sum.mass - center.cwiseProduct(center)).cwiseMax(0.);
    const Vec3d inertia = sum.mass * Vec3d(spread.y() + spread.z(), spread.x() + spread.z(), spread.x() + spread.y());
 
    // Beside the marker.
    const Point   screen = CameraUtils::project(wxGetApp().plater()->get_camera(), center);
    ImGuiWrapper& imgui  = *wxGetApp().imgui();
    imgui.set_next_window_pos(float(screen.x() + 2. * marker_radii[pick.kind] * marker_scale(canvas)), float(screen.y()), ImGuiCond_Always, 0.f, 0.5f);
    const std::string title = pick.kind == mkPlate  ? _u8L("Plate center of mass") :
                              pick.kind == mkBody   ? _u8L("Part center of mass") :
                              pick.kind == mkSupport ? _u8L("Support center of mass") :
                              marker.assembly       ? _u8L("Assembly center of mass") :
                                                      _u8L("Object center of mass");
    bool open = true;
    imgui.begin(title + "###center_of_mass", &open,
                ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoSavedSettings);
    if (ImGui::IsWindowAppearing())
        imgui.set_requires_extra_frame();
    if (canvas.get_canvas_type() == ECanvasType::CanvasPreview)
        imgui.text(pick.set == 0 ? _u8L("Finished print") : (boost::format(_u8L("Printed up to layer %1%")) % (m_top_layer + 1)).str());
    // Masses are in mg, volumes in mm³.
    const auto xyz = [](const Vec3d& v, const char* format, const std::string& unit) {
        return (boost::format(format) % v.x() % v.y() % v.z()).str() + " " + unit;
    };
    if (ImGui::BeginTable("##center_of_mass_details", 2)) {
        const auto row = [](const std::string& label, const std::string& value) {
            ImGui::TableNextRow();
            ImGui::TableSetColumnIndex(0);
            ImGuiWrapper::text_colored(ImGuiWrapper::COL_ORCA, label);
            ImGui::TableSetColumnIndex(1);
            ImGuiWrapper::text(value);
        };
        row(_u8L("Weight"), (boost::format("%.2f g") % (sum.mass / 1000.)).str());
        row(_u8L("Volume"), (boost::format(u8"%.2f cm³") % (sum.volume / 1000.)).str());
        if (marker.box.defined) {
            row(_u8L("Center in bounding box"), xyz(center - marker.box.min, "X: %.2f, Y: %.2f, Z: %.2f", _u8L("mm")));
            row(_u8L("Bounding box size"), xyz(marker.box.size(), "X: %.2f, Y: %.2f, Z: %.2f", _u8L("mm")));
        }
        row(_u8L("Moment of inertia"), xyz(inertia / 1000., "X: %.0f, Y: %.0f, Z: %.0f", u8"g·mm²"));
        ImGui::EndTable();
    }
    imgui.end();
    if (!open) {
        m_picked.reset();
        canvas._set_overlay_as_dirty();
    }
}

References Slic3r::GUI::GLCanvas3D::GLCanvas3D(), Slic3r::GUI::GLCanvas3D::_set_overlay_as_dirty(), _u8L, Slic3r::GUI::GLCanvas3D::CenterOfMass::Marker::assembly, Slic3r::GUI::ImGuiWrapper::begin(), Slic3r::GUI::GLCanvas3D::CenterOfMass::Marker::box, Slic3r::GUI::GLCanvas3D::CanvasPreview, Slic3r::center(), Slic3r::GUI::GLCanvas3D::CenterOfMass::Marker::center(), Slic3r::GUI::ImGuiWrapper::COL_ORCA, Slic3r::GUI::GLCanvas3D::CenterOfMass::Pick::count, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::defined, Slic3r::GUI::ImGuiWrapper::end(), Slic3r::GUI::format(), Slic3r::GUI::GLCanvas3D::get_camera(), Slic3r::GUI::GLCanvas3D::get_canvas_type(), Slic3r::GUI::GLCanvas3D::CenterOfMass::Pick::index, Slic3r::GUI::GLCanvas3D::CenterOfMass::Pick::kind, m_drawn, m_picked, m_top_layer, Slic3r::GUI::marker_radii, Slic3r::GUI::marker_scale(), Slic3r::GCodeProcessorResult::ObjectMass::Sum::mass, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, mkBody, mkPlate, mkSupport, Slic3r::GUI::plater(), Slic3r::GUI::CameraUtils::project(), render_details(), Slic3r::GCodeProcessorResult::ObjectMass::Sum::second, Slic3r::GUI::GLCanvas3D::CenterOfMass::Pick::set, Slic3r::GUI::ImGuiWrapper::set_next_window_pos(), Slic3r::GUI::ImGuiWrapper::set_requires_extra_frame(), Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::GUI::GLCanvas3D::CenterOfMass::Marker::sum, Slic3r::GUI::ImGuiWrapper::text(), Slic3r::GUI::ImGuiWrapper::text_colored(), and Slic3r::GCodeProcessorResult::ObjectMass::Sum::volume.

Referenced by render_details().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_bodies

std::map<size_t, Bodies> Slic3r::GUI::GLCanvas3D::CenterOfMass::m_bodies

private

Referenced by model_markers().

m_drawn

std::array<Markers, 2> Slic3r::GUI::GLCanvas3D::CenterOfMass::m_drawn

private

Referenced by on_left_down(), render(), and render_details().

m_meshes

std::map<size_t, MassProperties> Slic3r::GUI::GLCanvas3D::CenterOfMass::m_meshes

private

Referenced by model_markers().

m_octants

std::array<GLModel, 2> Slic3r::GUI::GLCanvas3D::CenterOfMass::m_octants

private

m_picked

std::optional<Pick> Slic3r::GUI::GLCanvas3D::CenterOfMass::m_picked

private

Referenced by on_left_down(), and render_details().

m_top_layer

size_t Slic3r::GUI::GLCanvas3D::CenterOfMass::m_top_layer { 0 }

private

{ 0 };

Referenced by render(), and render_details().

---

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