3DPrinting/PrusaSlicer-NonPlainar
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Gizmo measure modified to accept single full instance selection, to combine the volumes meshes into a single mesh and pass it to the back end after transform it in world coordinates

Browse Source 
Changes embedded into tech ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
This commit is contained in:
enricoturri1966 2022-11-15 12:17:18 +01:00
parent 1ba4227633
commit 3c0e331363
9 changed files with 338 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
src/libslic3r/Measure.cpp
View File

@ -45,6 +45,9 @@ public:
std::optional<SurfaceFeature> get_feature(size_t face_idx, const Vec3d& point) const;
std::vector<std::vector<int>> get_planes_triangle_indices() const;
const std::vector<SurfaceFeature>& get_plane_features(unsigned int plane_id) const;
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const TriangleMesh& get_mesh() const;
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
private:
void update_planes();
@ -52,7 +55,11 @@ private:
std::vector<PlaneData> m_planes;
std::vector<size_t> m_face_to_plane;
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
TriangleMesh m_mesh;
#else
const indexed_triangle_set& m_its;
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
};
@ -61,7 +68,11 @@ private:
MeasuringImpl::MeasuringImpl(const indexed_triangle_set& its)
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
: m_mesh(its)
#else
: m_its{its}
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
{
update_planes();
extract_features();
@ -74,10 +85,17 @@ void MeasuringImpl::update_planes()
// Now we'll go through all the facets and append Points of facets sharing the same normal.
// This part is still performed in mesh coordinate system.
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const size_t num_of_facets = m_mesh.its.indices.size();
m_face_to_plane.resize(num_of_facets, size_t(-1));
const std::vector<Vec3f> face_normals = its_face_normals(m_mesh.its);
const std::vector<Vec3i> face_neighbors = its_face_neighbors(m_mesh.its);
#else
const size_t num_of_facets = m_its.indices.size();
m_face_to_plane.resize(num_of_facets, size_t(-1));
const std::vector<Vec3f> face_normals = its_face_normals(m_its);
const std::vector<Vec3i> face_neighbors = its_face_neighbors(m_its);
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
std::vector<int> facet_queue(num_of_facets, 0);
int facet_queue_cnt = 0;
const stl_normal* normal_ptr = nullptr;
@ -126,7 +144,11 @@ void MeasuringImpl::update_planes()
assert(std::none_of(m_face_to_plane.begin(), m_face_to_plane.end(), [](size_t val) { return val == size_t(-1); }));
// Now we will walk around each of the planes and save vertices which form the border.
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
SurfaceMesh sm(m_mesh.its);
#else
SurfaceMesh sm(m_its);
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
for (int plane_id=0; plane_id < int(m_planes.size()); ++plane_id) {
const auto& facets = m_planes[plane_id].facets;
m_planes[plane_id].borders.clear();
@ -508,6 +530,12 @@ const std::vector<SurfaceFeature>& MeasuringImpl::get_plane_features(unsigned in
return m_planes[plane_id].surface_features;
}
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const TriangleMesh& MeasuringImpl::get_mesh() const
{
return this->m_mesh;
}
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
@ -549,6 +577,13 @@ const std::vector<SurfaceFeature>& Measuring::get_plane_features(unsigned int pl
return priv->get_plane_features(plane_id);
}
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const TriangleMesh& Measuring::get_mesh() const
{
return priv->get_mesh();
}
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const AngleAndEdges AngleAndEdges::Dummy = { 0.0, Vec3d::Zero(), { Vec3d::Zero(), Vec3d::Zero() }, { Vec3d::Zero(), Vec3d::Zero() }, 0.0, true };
static AngleAndEdges angle_edge_edge(const std::pair<Vec3d, Vec3d>& e1, const std::pair<Vec3d, Vec3d>& e2)
@ -1147,6 +1182,7 @@ MeasurementResult get_measurement(const SurfaceFeature& a, const SurfaceFeature&
return result;
}
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
void DistAndPoints::transform(const Transform3d& trafo) {
from = trafo * from;
to = trafo * to;
@ -1167,6 +1203,7 @@ void AngleAndEdges::transform(const Transform3d& trafo) {
const double average_scale = 0.5 * (new_e1.norm() / old_e1.norm() + new_e2.norm() / old_e2.norm());
radius = average_scale * radius;
}
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES

19
src/libslic3r/Measure.hpp
View File

@ -87,9 +87,11 @@ class MeasuringImpl;
class Measuring {
public:
// Construct the measurement object on a given its. The its must remain
// valid and unchanged during the whole lifetime of the object.
explicit Measuring(const indexed_triangle_set& its);
// Construct the measurement object on a given its.
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
// The its must remain valid and unchanged during the whole lifetime of the object.
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
explicit Measuring(const indexed_triangle_set& its);
~Measuring();
// Return a reference to a list of all features identified on the its.
@ -108,6 +110,11 @@ public:
// Returns the surface features of the plane with the given index
const std::vector<SurfaceFeature>& get_plane_features(unsigned int plane_id) const;
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
// Returns the mesh used for measuring
const TriangleMesh& get_mesh() const;
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
private:
std::unique_ptr<MeasuringImpl> priv;
};
@ -119,7 +126,9 @@ struct DistAndPoints {
Vec3d from;
Vec3d to;
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
void transform(const Transform3d& trafo);
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
};
struct AngleAndEdges {
@ -132,7 +141,9 @@ struct AngleAndEdges {
double radius;
bool coplanar;
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
void transform(const Transform3d& trafo);
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
static const AngleAndEdges Dummy;
};
@ -151,6 +162,7 @@ struct MeasurementResult {
return angle.has_value() || distance_infinite.has_value() || distance_strict.has_value() || distance_xyz.has_value();
}
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
void transform(const Transform3d& trafo) {
if (angle.has_value())
angle->transform(trafo);
@ -161,6 +173,7 @@ struct MeasurementResult {
distance_xyz = (distance_strict->to - distance_strict->from).cwiseAbs();
}
}
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
};
// Returns distance/angle between two SurfaceFeatures.

2
src/libslic3r/Technologies.hpp
View File

@ -64,6 +64,8 @@
// Enable picking using raytracing
#define ENABLE_RAYCAST_PICKING (1 && ENABLE_LEGACY_OPENGL_REMOVAL)
#define ENABLE_RAYCAST_PICKING_DEBUG (0 && ENABLE_RAYCAST_PICKING)
// Enable gizmo measure combining volumes meshes and passing them to the backend in world coordinates
#define ENABLE_GIZMO_MEASURE_WORLD_COORDINATES (1 && ENABLE_2_5_0_ALPHA1)
#endif // _prusaslicer_technologies_h_

215
src/slic3r/GUI/Gizmos/GLGizmoMeasure.cpp
View File

@ -5,9 +5,11 @@
#include "slic3r/GUI/Plater.hpp"
#include "slic3r/GUI/GUI_ObjectManipulation.hpp"
#include "slic3r/GUI/Gizmos/GLGizmosCommon.hpp"
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
#include "slic3r/GUI/Gizmos/GLGizmosCommon.hpp"
#include "libslic3r/Model.hpp"
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
#include "libslic3r/PresetBundle.hpp"
#include "libslic3r/MeasureUtils.hpp"
@ -242,7 +244,10 @@ private:
TransformHelper::Cache TransformHelper::s_cache = { { 0, 0, 0, 0 }, Matrix4d::Identity(), Transform3d::Identity() };
GLGizmoMeasure::GLGizmoMeasure(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id)
: GLGizmoBase(parent, icon_filename, sprite_id)
: GLGizmoBase(parent, icon_filename, sprite_id)
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
, m_raycaster(nullptr)
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
{
GLModel::Geometry sphere_geometry = smooth_sphere(16, 7.5f);
m_sphere.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(sphere_geometry.get_as_indexed_triangle_set()));
@ -370,8 +375,10 @@ bool GLGizmoMeasure::on_mouse(const wxMouseEvent &mouse_event)
if (m_selected_features != selected_features_old && m_selected_features.second.feature.has_value()) {
m_measurement_result = Measure::get_measurement(*m_selected_features.first.feature, *m_selected_features.second.feature, m_measuring.get());
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
// transform to world coordinates
m_measurement_result.transform(m_volume_matrix);
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
}
m_imgui->set_requires_extra_frame();
@ -419,6 +426,9 @@ bool GLGizmoMeasure::on_mouse(const wxMouseEvent &mouse_event)
void GLGizmoMeasure::data_changed()
{
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
update_if_needed();
#else
const Selection& selection = m_parent.get_selection();
const ModelObject* model_object = nullptr;
const ModelVolume* model_volume = nullptr;
@ -429,13 +439,16 @@ void GLGizmoMeasure::data_changed()
}
if (model_object != m_old_model_object || model_volume != m_old_model_volume)
update_if_needed();
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
m_last_inv_zoom = 0.0f;
m_last_plane_idx = -1;
if (m_pending_scale) {
m_measurement_result = Measure::get_measurement(*m_selected_features.first.feature, *m_selected_features.second.feature, m_measuring.get());
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
// transform to world coordinates
m_measurement_result.transform(m_volume_matrix);
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
m_pending_scale = false;
}
else
@ -512,6 +525,9 @@ void GLGizmoMeasure::on_set_state()
m_editing_distance = false;
m_is_editing_distance_first_frame = true;
m_measuring.reset();
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
m_raycaster.release();
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
}
else {
m_mode = EMode::FeatureSelection;
@ -528,10 +544,12 @@ void GLGizmoMeasure::on_set_state()
}
}
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
CommonGizmosDataID GLGizmoMeasure::on_get_requirements() const
{
return CommonGizmosDataID(int(CommonGizmosDataID::SelectionInfo) | int(CommonGizmosDataID::Raycaster));
}
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
std::string GLGizmoMeasure::on_get_name() const
{
@ -543,9 +561,15 @@ bool GLGizmoMeasure::on_is_activable() const
const Selection& selection = m_parent.get_selection();
bool res = (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptSLA) ?
selection.is_single_full_instance() :
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
selection.is_single_full_instance() || selection.is_single_volume() || selection.is_single_modifier();
if (res)
res &= !selection.contains_sinking_volumes();
#else
selection.is_single_volume() || selection.is_single_volume_instance();
if (res)
res &= !selection.get_first_volume()->is_sinking();
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
return res;
}
@ -562,8 +586,10 @@ void GLGizmoMeasure::on_render()
const Selection& selection = m_parent.get_selection();
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
if ((wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptSLA && selection.is_single_full_instance()) ||
(selection.is_single_volume() || selection.is_single_volume_instance())) {
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
update_if_needed();
const Camera& camera = wxGetApp().plater()->get_camera();
@ -572,7 +598,11 @@ void GLGizmoMeasure::on_render()
Vec3f position_on_model;
Vec3f normal_on_model;
size_t model_facet_idx;
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const bool mouse_on_object = m_raycaster.raycaster()->unproject_on_mesh(m_mouse_pos, Transform3d::Identity(), camera, position_on_model, normal_on_model, nullptr, &model_facet_idx);
#else
const bool mouse_on_object = m_c->raycaster()->raycasters().front()->unproject_on_mesh(m_mouse_pos, m_volume_matrix, camera, position_on_model, normal_on_model, nullptr, &model_facet_idx);
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const bool is_hovering_on_feature = (m_mode == EMode::PointSelection || m_mode == EMode::CenterSelection) && m_hover_id != -1;
auto update_circle = [this, inv_zoom]() {
@ -581,7 +611,11 @@ void GLGizmoMeasure::on_render()
m_last_circle = m_curr_feature;
m_circle.reset();
const auto [center, radius, normal] = m_curr_feature->get_circle();
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
GLModel::Geometry circle_geometry = init_torus_data(64, 16, center.cast<float>(), float(radius), 5.0f * inv_zoom, normal.cast<float>(), Transform3f::Identity());
#else
GLModel::Geometry circle_geometry = init_torus_data(64, 16, center.cast<float>(), float(radius), 5.0f * inv_zoom, normal.cast<float>(), m_volume_matrix.cast<float>());
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
m_circle.mesh_raycaster = std::make_unique<MeshRaycaster>(std::make_shared<const TriangleMesh>(circle_geometry.get_as_indexed_triangle_set()));
m_circle.model.init_from(std::move(circle_geometry));
return true;
@ -639,7 +673,11 @@ void GLGizmoMeasure::on_render()
const auto [idx, normal, point] = m_curr_feature->get_plane();
if (m_last_plane_idx != idx) {
m_last_plane_idx = idx;
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const indexed_triangle_set& its = m_measuring->get_mesh().its;
#else
const indexed_triangle_set its = (m_old_model_volume != nullptr) ? m_old_model_volume->mesh().its : m_old_model_object->volumes.front()->mesh().its;
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const std::vector<std::vector<int>> planes_triangles = m_measuring->get_planes_triangle_indices();
GLModel::Geometry init_data = init_plane_data(its, planes_triangles, idx);
m_plane.reset();
@ -689,12 +727,20 @@ void GLGizmoMeasure::on_render()
if (extra.has_value() && m_hover_id == POINT_ID)
m_curr_point_on_feature_position = *extra;
else
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
m_curr_point_on_feature_position = position_on_feature(EDGE_ID, camera, [](const Vec3f& v) { return Vec3f(0.0f, 0.0f, v.z()); });
#else
m_curr_point_on_feature_position = m_volume_matrix.inverse() * position_on_feature(EDGE_ID, camera, [](const Vec3f& v) { return Vec3f(0.0f, 0.0f, v.z()); });
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
break;
}
case Measure::SurfaceFeatureType::Plane:
{
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
m_curr_point_on_feature_position = position_on_feature(PLANE_ID, camera);
#else
m_curr_point_on_feature_position = m_volume_matrix.inverse() * position_on_feature(PLANE_ID, camera);
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
break;
}
case Measure::SurfaceFeatureType::Circle:
@ -704,9 +750,17 @@ void GLGizmoMeasure::on_render()
m_curr_point_on_feature_position = center;
else {
const Vec3d world_pof = position_on_feature(CIRCLE_ID, camera, [](const Vec3f& v) { return v; });
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const Eigen::Hyperplane<double, 3> plane(normal, center);
#else
const Eigen::Hyperplane<double, 3> plane(m_volume_matrix.matrix().block(0, 0, 3, 3).inverse().transpose() * normal, m_volume_matrix * center);
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const Transform3d local_to_model_matrix = Geometry::translation_transform(center) * Eigen::Quaternion<double>::FromTwoVectors(Vec3d::UnitZ(), normal);
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const Vec3d local_proj = local_to_model_matrix.inverse() * plane.projection(world_pof);
#else
const Vec3d local_proj = local_to_model_matrix.inverse() * m_volume_matrix.inverse() * plane.projection(world_pof);
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
double angle = std::atan2(local_proj.y(), local_proj.x());
if (angle < 0.0)
angle += 2.0 * double(M_PI);
@ -767,8 +821,12 @@ void GLGizmoMeasure::on_render()
default: { assert(false); break; }
case Measure::SurfaceFeatureType::Point:
{
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const Transform3d feature_matrix = Geometry::translation_transform(feature.get_point()) * Geometry::scale_transform(inv_zoom);
#else
const Vec3d position = TransformHelper::model_to_world(feature.get_point(), m_volume_matrix);
const Transform3d feature_matrix = Geometry::translation_transform(position) * Geometry::scale_transform(inv_zoom);
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
set_matrix_uniforms(feature_matrix);
set_emission_uniform(colors.front(), hover);
m_sphere.model.set_color(colors.front());
@ -785,8 +843,12 @@ void GLGizmoMeasure::on_render()
const auto& [center, radius, normal] = feature.get_circle();
// render center
if (update_raycasters_transform) {
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const Transform3d center_matrix = Geometry::translation_transform(center) * Geometry::scale_transform(inv_zoom);
#else
const Vec3d center_world = TransformHelper::model_to_world(center, m_volume_matrix);
const Transform3d center_matrix = Geometry::translation_transform(center_world) * Geometry::scale_transform(inv_zoom);
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
set_matrix_uniforms(center_matrix);
set_emission_uniform(colors.front(), hover);
m_sphere.model.set_color(colors.front());
@ -809,7 +871,11 @@ void GLGizmoMeasure::on_render()
}
else {
GLModel circle;
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
GLModel::Geometry circle_geometry = init_torus_data(64, 16, center.cast<float>(), float(radius), 5.0f * inv_zoom, normal.cast<float>(), Transform3f::Identity());
#else
GLModel::Geometry circle_geometry = init_torus_data(64, 16, center.cast<float>(), float(radius), 5.0f * inv_zoom, normal.cast<float>(), m_volume_matrix.cast<float>());
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
circle.init_from(std::move(circle_geometry));
set_emission_uniform(colors.back(), hover);
circle.set_color(colors.back());
@ -825,8 +891,12 @@ void GLGizmoMeasure::on_render()
if (update_raycasters_transform) {
const std::optional<Vec3d> extra = feature.get_extra_point();
if (extra.has_value()) {
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const Transform3d point_matrix = Geometry::translation_transform(*extra) * Geometry::scale_transform(inv_zoom);
#else
const Vec3d extra_world = TransformHelper::model_to_world(*extra, m_volume_matrix);
const Transform3d point_matrix = Geometry::translation_transform(extra_world) * Geometry::scale_transform(inv_zoom);
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
set_matrix_uniforms(point_matrix);
set_emission_uniform(colors.front(), hover);
m_sphere.model.set_color(colors.front());
@ -838,11 +908,17 @@ void GLGizmoMeasure::on_render()
}
// render edge
if (m_mode != EMode::CenterSelection) {
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const Transform3d edge_matrix = Geometry::translation_transform(from) *
Eigen::Quaternion<double>::FromTwoVectors(Vec3d::UnitZ(), to - from) *
Geometry::scale_transform({ (double)inv_zoom, (double)inv_zoom, (to - from).norm() });
#else
const Vec3d from_world = TransformHelper::model_to_world(from, m_volume_matrix);
const Vec3d to_world = TransformHelper::model_to_world(to, m_volume_matrix);
const Transform3d edge_matrix = Geometry::translation_transform(from_world) *
Eigen::Quaternion<double>::FromTwoVectors(Vec3d::UnitZ(), to_world - from_world) *
Geometry::scale_transform({ (double)inv_zoom, (double)inv_zoom, (to_world - from_world).norm() });
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
set_matrix_uniforms(edge_matrix);
set_emission_uniform(colors.back(), hover);
m_cylinder.model.set_color(colors.back());
@ -861,7 +937,11 @@ void GLGizmoMeasure::on_render()
if (colors.front() != m_parent.get_selection().get_first_volume()->render_color) {
const auto& [idx, normal, pt] = feature.get_plane();
assert(idx < m_plane_models_cache.size());
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
set_matrix_uniforms(Transform3d::Identity());
#else
set_matrix_uniforms(m_volume_matrix);
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
set_emission_uniform(colors.front(), hover);
m_plane_models_cache[idx].set_color(colors.front());
m_plane_models_cache[idx].render();
@ -869,7 +949,11 @@ void GLGizmoMeasure::on_render()
if (update_raycasters_transform) {
auto it = m_raycasters.find(PLANE_ID);
if (it != m_raycasters.end() && it->second != nullptr)
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
it->second->set_transform(Transform3d::Identity());
#else
it->second->set_transform(m_volume_matrix);
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
}
break;
}
@ -924,7 +1008,11 @@ void GLGizmoMeasure::on_render()
auto it = std::find_if(m_selection_raycasters.begin(), m_selection_raycasters.end(),
[](std::shared_ptr<SceneRaycasterItem> item) { return SceneRaycaster::decode_id(SceneRaycaster::EType::Gizmo, item->get_id()) == SELECTION_1_ID; });
if (it != m_selection_raycasters.end())
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
(*it)->set_transform(Geometry::translation_transform(m_selected_features.first.feature->get_point()) * Geometry::scale_transform(inv_zoom));
#else
(*it)->set_transform(m_volume_matrix * Geometry::translation_transform(m_selected_features.first.feature->get_point()) * Geometry::scale_transform(inv_zoom));
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
}
}
if (m_selected_features.second.feature.has_value() && (!m_curr_feature.has_value() || *m_curr_feature != *m_selected_features.second.feature)) {
@ -934,14 +1022,22 @@ void GLGizmoMeasure::on_render()
auto it = std::find_if(m_selection_raycasters.begin(), m_selection_raycasters.end(),
[](std::shared_ptr<SceneRaycasterItem> item) { return SceneRaycaster::decode_id(SceneRaycaster::EType::Gizmo, item->get_id()) == SELECTION_2_ID; });
if (it != m_selection_raycasters.end())
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
(*it)->set_transform(Geometry::translation_transform(m_selected_features.second.feature->get_point()) * Geometry::scale_transform(inv_zoom));
#else
(*it)->set_transform(m_volume_matrix * Geometry::translation_transform(m_selected_features.second.feature->get_point()) * Geometry::scale_transform(inv_zoom));
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
}
}
if (is_hovering_on_feature && m_curr_point_on_feature_position.has_value()) {
if (m_hover_id != POINT_ID) {
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const Transform3d matrix = Geometry::translation_transform(*m_curr_point_on_feature_position) * Geometry::scale_transform(inv_zoom);
#else
const Vec3d position = TransformHelper::model_to_world(*m_curr_point_on_feature_position, m_volume_matrix);
const Transform3d matrix = Geometry::translation_transform(position) * Geometry::scale_transform(inv_zoom);
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
set_matrix_uniforms(matrix);
const ColorRGBA color = hover_selection_color();
set_emission_uniform(color, true);
@ -954,7 +1050,9 @@ void GLGizmoMeasure::on_render()
if (old_cullface)
glsafe(::glEnable(GL_CULL_FACE));
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
}
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
render_dimensioning();
}
@ -971,6 +1069,24 @@ void GLGizmoMeasure::update_if_needed()
}
};
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
auto do_update = [this, update_plane_models_cache](const std::vector<VolumeCacheItem>& volumes_cache, const Selection& selection) {
TriangleMesh composite_mesh;
for (const auto& vol : volumes_cache) {
// if (selection.is_single_full_instance() && vol.volume->is_modifier())
// continue;
TriangleMesh volume_mesh = vol.volume->mesh();
volume_mesh.transform(vol.instance->get_transformation().get_matrix() * vol.volume->get_transformation().get_matrix());
composite_mesh.merge(volume_mesh);
}
m_measuring.reset(new Measure::Measuring(composite_mesh.its));
update_plane_models_cache(m_measuring->get_mesh().its);
m_raycaster.update_from(m_measuring->get_mesh());
m_volumes_cache = volumes_cache;
};
#else
auto do_update = [this, update_plane_models_cache](const ModelObject* object, const ModelVolume* volume) {
const indexed_triangle_set& its = (volume != nullptr) ? volume->mesh().its : object->volumes.front()->mesh().its;
m_measuring.reset(new Measure::Measuring(its));
@ -980,24 +1096,44 @@ void GLGizmoMeasure::update_if_needed()
// Let's save what we calculated it from:
m_volumes_matrices.clear();
m_volumes_types.clear();
m_first_instance_scale = Vec3d::Ones();
m_first_instance_scale = Vec3d::Ones();
m_first_instance_mirror = Vec3d::Ones();
if (object != nullptr) {
for (const ModelVolume* vol : object->volumes) {
m_volumes_matrices.push_back(vol->get_matrix());
m_volumes_types.push_back(vol->type());
}
m_first_instance_scale = object->instances.front()->get_scaling_factor();
m_first_instance_scale = object->instances.front()->get_scaling_factor();
m_first_instance_mirror = object->instances.front()->get_mirror();
}
m_old_model_object = object;
m_old_model_volume = volume;
};
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const Selection& selection = m_parent.get_selection();
if (selection.is_empty())
return;
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const Selection::IndicesList& idxs = selection.get_volume_idxs();
std::vector<VolumeCacheItem> volumes_cache;
volumes_cache.reserve(idxs.size());
for (unsigned int idx : idxs) {
const GLVolume* v = selection.get_volume(idx);
const ModelObject* obj = selection.get_model()->objects[v->object_idx()];
const ModelInstance* inst = obj->instances[v->instance_idx()];
const ModelVolume* vol = obj->volumes[v->volume_idx()];
const VolumeCacheItem item = { obj, inst, vol, inst->get_matrix() * vol->get_matrix() };
volumes_cache.emplace_back(item);
}
if (m_state != On || volumes_cache.empty())
return;
if (m_measuring == nullptr || m_volumes_cache != volumes_cache)
do_update(volumes_cache, selection);
#else
m_volume_matrix = selection.get_first_volume()->world_matrix();
const ModelObject* mo = m_c->selection_info()->model_object();
@ -1026,6 +1162,7 @@ void GLGizmoMeasure::update_if_needed()
break;
}
}
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
}
void GLGizmoMeasure::disable_scene_raycasters()
@ -1145,6 +1282,62 @@ void GLGizmoMeasure::render_dimensioning()
const double ratio = new_value / old_value;
wxGetApp().plater()->take_snapshot(_L("Scale"));
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
struct TrafoData
{
double ratio;
Vec3d old_pivot;
Vec3d new_pivot;
Transform3d scale_matrix;
TrafoData(double ratio, const Vec3d& pivot) {
this->ratio = ratio;
this->scale_matrix = Geometry::scale_transform(ratio);
this->old_pivot = pivot;
this->new_pivot = { pivot.x(), pivot.y(), (this->scale_matrix * pivot).z() };
}
Vec3d transform(const Vec3d& point) const {
return this->scale_matrix * (point - this->old_pivot) + this->new_pivot;
}
};
auto scale_feature = [this](Measure::SurfaceFeature& feature, const TrafoData& trafo_data) {
switch (feature.get_type())
{
case Measure::SurfaceFeatureType::Point:
{
feature = Measure::SurfaceFeature(trafo_data.transform(feature.get_point()));
break;
}
case Measure::SurfaceFeatureType::Edge:
{
const auto [from, to] = feature.get_edge();
const std::optional<Vec3d> extra = feature.get_extra_point();
const std::optional<Vec3d> new_extra = extra.has_value() ? trafo_data.transform(*extra) : extra;
feature = Measure::SurfaceFeature(Measure::SurfaceFeatureType::Edge, trafo_data.transform(from), trafo_data.transform(to), new_extra);
break;
}
case Measure::SurfaceFeatureType::Circle:
{
const auto [center, radius, normal] = feature.get_circle();
feature = Measure::SurfaceFeature(Measure::SurfaceFeatureType::Circle, trafo_data.transform(center), normal, std::nullopt, trafo_data.ratio * radius);
break;
}
case Measure::SurfaceFeatureType::Plane:
{
const auto [idx, normal, origin] = feature.get_plane();
feature = Measure::SurfaceFeature(Measure::SurfaceFeatureType::Plane, normal, trafo_data.transform(origin), std::nullopt, idx);
break;
}
}
};
const TrafoData trafo_data(ratio, m_parent.get_selection().get_bounding_box().center());
scale_feature(*m_selected_features.first.feature, trafo_data);
scale_feature(*m_selected_features.second.feature, trafo_data);
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
TransformationType type;
type.set_world();
type.set_relative();
@ -1203,8 +1396,10 @@ void GLGizmoMeasure::render_dimensioning()
assert(f1.get_type() == Measure::SurfaceFeatureType::Point && f2.get_type() == Measure::SurfaceFeatureType::Edge);
std::pair<Vec3d, Vec3d> e = f2.get_edge();
// Transform to world coordinates
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
e.first = TransformHelper::model_to_world(e.first, m_volume_matrix);
e.second = TransformHelper::model_to_world(e.second, m_volume_matrix);
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const Vec3d v_proj = m_measurement_result.distance_infinite->to;
@ -1485,15 +1680,21 @@ void GLGizmoMeasure::render_debug_dialog()
{
case Measure::SurfaceFeatureType::Point:
{
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
add_strings_row_to_table(*m_imgui, "m_pt1", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(item.feature->get_point()), ImGui::GetStyleColorVec4(ImGuiCol_Text));
#else
const Vec3d position = m_volume_matrix * item.feature->get_point();
add_strings_row_to_table(*m_imgui, "m_pt1", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(position), ImGui::GetStyleColorVec4(ImGuiCol_Text));
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
break;
}
case Measure::SurfaceFeatureType::Edge:
{
auto [from, to] = item.feature->get_edge();
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
from = m_volume_matrix * from;
to = m_volume_matrix * to;
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
add_strings_row_to_table(*m_imgui, "m_pt1", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(from), ImGui::GetStyleColorVec4(ImGuiCol_Text));
add_strings_row_to_table(*m_imgui, "m_pt2", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(to), ImGui::GetStyleColorVec4(ImGuiCol_Text));
break;
@ -1501,8 +1702,10 @@ void GLGizmoMeasure::render_debug_dialog()
case Measure::SurfaceFeatureType::Plane:
{
auto [idx, normal, origin] = item.feature->get_plane();
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
origin = m_volume_matrix * origin;
normal = m_volume_matrix.matrix().block(0, 0, 3, 3).inverse().transpose() * normal;
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
add_strings_row_to_table(*m_imgui, "m_pt1", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(normal), ImGui::GetStyleColorVec4(ImGuiCol_Text));
add_strings_row_to_table(*m_imgui, "m_pt2", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(origin), ImGui::GetStyleColorVec4(ImGuiCol_Text));
add_strings_row_to_table(*m_imgui, "m_value", ImGuiWrapper::COL_ORANGE_LIGHT, format_double(idx), ImGui::GetStyleColorVec4(ImGuiCol_Text));
@ -1511,9 +1714,13 @@ void GLGizmoMeasure::render_debug_dialog()
case Measure::SurfaceFeatureType::Circle:
{
auto [center, radius, normal] = item.feature->get_circle();
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const Vec3d on_circle = center + radius * Measure::get_orthogonal(normal, true);
#else
const Vec3d on_circle = m_volume_matrix * (center + radius * Measure::get_orthogonal(normal, true));
center = m_volume_matrix * center;
normal = (m_volume_matrix.matrix().block(0, 0, 3, 3).inverse().transpose() * normal).normalized();
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
radius = (on_circle - center).norm();
add_strings_row_to_table(*m_imgui, "m_pt1", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(center), ImGui::GetStyleColorVec4(ImGuiCol_Text));
add_strings_row_to_table(*m_imgui, "m_pt2", ImGuiWrapper::COL_ORANGE_LIGHT, format_vec3(normal), ImGui::GetStyleColorVec4(ImGuiCol_Text));

35
src/slic3r/GUI/Gizmos/GLGizmoMeasure.hpp
View File

@ -5,10 +5,16 @@
#include "slic3r/GUI/GLModel.hpp"
#include "slic3r/GUI/GUI_Utils.hpp"
#include "libslic3r/Measure.hpp"
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
#include "slic3r/GUI/Gizmos/GLGizmosCommon.hpp"
#include "libslic3r/Model.hpp"
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
namespace Slic3r {
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
class ModelVolume;
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
enum class ModelVolumeType : int;
@ -68,6 +74,23 @@ class GLGizmoMeasure : public GLGizmoBase
}
};
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
struct VolumeCacheItem
{
const ModelObject* object{ nullptr };
const ModelInstance* instance{ nullptr };
const ModelVolume* volume{ nullptr };
Transform3d world_trafo;
bool operator == (const VolumeCacheItem& other) const {
return this->object == other.object && this->instance == other.instance && this->volume == other.volume &&
this->world_trafo.isApprox(other.world_trafo);
}
};
std::vector<VolumeCacheItem> m_volumes_cache;
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
EMode m_mode{ EMode::FeatureSelection };
Measure::MeasurementResult m_measurement_result;
@ -85,7 +108,13 @@ class GLGizmoMeasure : public GLGizmoBase
};
Dimensioning m_dimensioning;
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
// Uses a standalone raycaster and not the shared one because of the
// difference in how the mesh is updated
CommonGizmosDataObjects::Raycaster m_raycaster;
#else
Transform3d m_volume_matrix{ Transform3d::Identity() };
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
std::vector<GLModel> m_plane_models_cache;
std::map<int, std::shared_ptr<SceneRaycasterItem>> m_raycasters;
std::vector<std::shared_ptr<SceneRaycasterItem>> m_selection_raycasters;
@ -100,17 +129,21 @@ class GLGizmoMeasure : public GLGizmoBase
std::vector<SceneRaycasterState> m_scene_raycasters;
// These hold information to decide whether recalculation is necessary:
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
std::vector<Transform3d> m_volumes_matrices;
std::vector<ModelVolumeType> m_volumes_types;
Vec3d m_first_instance_scale{ Vec3d::Ones() };
Vec3d m_first_instance_mirror{ Vec3d::Ones() };
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
float m_last_inv_zoom{ 0.0f };
std::optional<Measure::SurfaceFeature> m_last_circle;
int m_last_plane_idx{ -1 };
bool m_mouse_left_down{ false }; // for detection left_up of this gizmo
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
const ModelObject* m_old_model_object{ nullptr };
const ModelVolume* m_old_model_volume{ nullptr };
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
Vec2d m_mouse_pos{ Vec2d::Zero() };
@ -153,7 +186,9 @@ protected:
bool on_is_activable() const override;
void on_render() override;
void on_set_state() override;
#if !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
CommonGizmosDataID on_get_requirements() const override;
#endif // !ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
virtual void on_render_input_window(float x, float y, float bottom_limit) override;
virtual void on_register_raycasters_for_picking() override;

13
src/slic3r/GUI/Gizmos/GLGizmosCommon.cpp
View File

@ -327,6 +327,19 @@ const TriangleMesh* HollowedMesh::get_hollowed_interior() const
}
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
void Raycaster::update_from(const TriangleMesh& mesh)
{
std::vector<const TriangleMesh*> meshes = { &mesh };
if (meshes != m_old_meshes) {
wxBusyCursor wait;
m_raycasters.clear();
m_raycasters.emplace_back(new MeshRaycaster(std::make_shared<const TriangleMesh>(mesh)));
m_old_meshes = meshes;
}
validate();
}
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
void Raycaster::on_update()

7
src/slic3r/GUI/Gizmos/GLGizmosCommon.hpp
View File

@ -137,6 +137,9 @@ protected:
virtual void on_update() = 0;
CommonGizmosDataPool* get_pool() const { return m_common; }
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
void validate() { m_is_valid = true; }
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
private:
bool m_is_valid = false;
@ -242,6 +245,10 @@ public:
const MeshRaycaster* raycaster() const { assert(m_raycasters.size() == 1); return m_raycasters.front().get(); }
std::vector<const MeshRaycaster*> raycasters() const;
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
void update_from(const TriangleMesh& mesh);
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
protected:
void on_update() override;
void on_release() override;

13
src/slic3r/GUI/Selection.cpp
View File

@ -602,6 +602,19 @@ bool Selection::contains_any_volume(const std::vector<unsigned int>& volume_idxs
return false;
}
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
bool Selection::contains_sinking_volumes(bool ignore_modifiers) const
{
for (const GLVolume* v : *m_volumes) {
if (!ignore_modifiers || !v->is_modifier) {
if (v->is_sinking())
return true;
}
}
return false;
}
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
bool Selection::matches(const std::vector<unsigned int>& volume_idxs) const
{
unsigned int count = 0;

4
src/slic3r/GUI/Selection.hpp
View File

@ -337,6 +337,10 @@ public:
bool contains_all_volumes(const std::vector<unsigned int>& volume_idxs) const;
// returns true if the selection contains at least one of the given indices
bool contains_any_volume(const std::vector<unsigned int>& volume_idxs) const;
#if ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
// returns true if the selection contains any sinking volume
bool contains_sinking_volumes(bool ignore_modifiers = true) const;
#endif // ENABLE_GIZMO_MEASURE_WORLD_COORDINATES
// returns true if the selection contains all and only the given indices
bool matches(const std::vector<unsigned int>& volume_idxs) const;