mirror of
https://github.com/OrcaSlicer/OrcaSlicer.git
synced 2026-08-30 13:26:58 +00:00
Merge branch 'main' into dev/step-import-dialog
This commit is contained in:
SoftFever
@@ -227,7 +227,71 @@ bool GLGizmoBase::render_combo(const std::string &label, const std::vector<std::
|
||||
return is_changed;
|
||||
}
|
||||
|
||||
GLGizmoBase::GLGizmoBase(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id)
|
||||
void GLGizmoBase::render_cross_mark(const Vec3f &target, bool is_single)
|
||||
{
|
||||
const float half_length = 4.0f;
|
||||
|
||||
glsafe(::glLineWidth(2.0f));
|
||||
|
||||
auto render_line = [](const Vec3f& p1, const Vec3f& p2, const ColorRGBA& color) {
|
||||
GLModel::Geometry init_data;
|
||||
init_data.format = {GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3};
|
||||
init_data.color = color;
|
||||
init_data.reserve_vertices(2);
|
||||
init_data.reserve_indices(2);
|
||||
|
||||
// vertices
|
||||
init_data.add_vertex(p1);
|
||||
init_data.add_vertex(p2);
|
||||
|
||||
// indices
|
||||
init_data.add_line(0, 1);
|
||||
|
||||
GLModel model;
|
||||
model.init_from(std::move(init_data));
|
||||
model.render();
|
||||
};
|
||||
|
||||
// draw line for x axis
|
||||
if (!is_single) {
|
||||
render_line(
|
||||
{target(0) - half_length, target(1), target(2)},
|
||||
{target(0) + half_length, target(1), target(2)},
|
||||
ColorRGBA::RED());
|
||||
}
|
||||
else {
|
||||
render_line(
|
||||
{target(0), target(1), target(2)},
|
||||
{target(0) + half_length, target(1), target(2)},
|
||||
ColorRGBA::RED());
|
||||
}
|
||||
// draw line for y axis
|
||||
if (!is_single) {
|
||||
render_line(
|
||||
{target(0), target(1) - half_length, target(2)},
|
||||
{target(0), target(1) + half_length, target(2)},
|
||||
ColorRGBA::GREEN());
|
||||
} else {
|
||||
render_line(
|
||||
{target(0), target(1), target(2)},
|
||||
{target(0), target(1) + half_length, target(2)},
|
||||
ColorRGBA::GREEN());
|
||||
}
|
||||
// draw line for z axis
|
||||
if (!is_single) {
|
||||
render_line(
|
||||
{target(0), target(1), target(2) - half_length},
|
||||
{target(0), target(1), target(2) + half_length},
|
||||
ColorRGBA::BLUE());
|
||||
} else {
|
||||
render_line(
|
||||
{target(0), target(1), target(2)},
|
||||
{target(0), target(1), target(2) + half_length},
|
||||
ColorRGBA::BLUE());
|
||||
}
|
||||
}
|
||||
|
||||
GLGizmoBase::GLGizmoBase(GLCanvas3D &parent, const std::string &icon_filename, unsigned int sprite_id)
|
||||
: m_parent(parent)
|
||||
, m_group_id(-1)
|
||||
, m_state(Off)
|
||||
|
||||
@@ -152,7 +152,7 @@ protected:
|
||||
|
||||
bool render_combo(const std::string &label, const std::vector<std::string> &lines,
|
||||
int &selection_idx, float label_width, float item_width);
|
||||
|
||||
void render_cross_mark(const Vec3f& target,bool is_single =false);
|
||||
public:
|
||||
GLGizmoBase(GLCanvas3D& parent,
|
||||
const std::string& icon_filename,
|
||||
|
||||
@@ -48,6 +48,7 @@ bool GLGizmoMove3D::on_mouse(const wxMouseEvent &mouse_event) {
|
||||
|
||||
void GLGizmoMove3D::data_changed(bool is_serializing) {
|
||||
m_grabbers[2].enabled = !m_parent.get_selection().is_wipe_tower();
|
||||
change_cs_by_selection();
|
||||
}
|
||||
|
||||
bool GLGizmoMove3D::on_init()
|
||||
@@ -67,7 +68,11 @@ bool GLGizmoMove3D::on_init()
|
||||
|
||||
std::string GLGizmoMove3D::on_get_name() const
|
||||
{
|
||||
return _u8L("Move");
|
||||
if (!on_is_activable() && m_state == EState::Off) {
|
||||
return _u8L("Move") + ":\n" + _u8L("Please select at least one object.");
|
||||
} else {
|
||||
return _u8L("Move");
|
||||
}
|
||||
}
|
||||
|
||||
bool GLGizmoMove3D::on_is_activable() const
|
||||
@@ -75,13 +80,21 @@ bool GLGizmoMove3D::on_is_activable() const
|
||||
return !m_parent.get_selection().is_empty();
|
||||
}
|
||||
|
||||
void GLGizmoMove3D::on_set_state() {
|
||||
if (get_state() == On) {
|
||||
m_last_selected_obejct_idx = -1;
|
||||
m_last_selected_volume_idx = -1;
|
||||
change_cs_by_selection();
|
||||
}
|
||||
}
|
||||
|
||||
void GLGizmoMove3D::on_start_dragging()
|
||||
{
|
||||
assert(m_hover_id != -1);
|
||||
|
||||
m_displacement = Vec3d::Zero();
|
||||
const BoundingBoxf3& box = m_parent.get_selection().get_bounding_box();
|
||||
m_starting_drag_position = m_grabbers[m_hover_id].center;
|
||||
m_starting_drag_position = m_grabbers[m_hover_id].matrix * m_grabbers[m_hover_id].center;
|
||||
m_starting_box_center = box.center();
|
||||
m_starting_box_bottom_center = box.center();
|
||||
m_starting_box_bottom_center(2) = box.min(2);
|
||||
@@ -121,42 +134,38 @@ void GLGizmoMove3D::on_render()
|
||||
glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
|
||||
glsafe(::glEnable(GL_DEPTH_TEST));
|
||||
|
||||
const BoundingBoxf3& box = selection.get_bounding_box();
|
||||
const Vec3d& center = box.center();
|
||||
const auto &[box, box_trafo] = selection.get_bounding_box_in_current_reference_system();
|
||||
m_bounding_box = box;
|
||||
m_center = box_trafo.translation();
|
||||
if (m_object_manipulation) {
|
||||
m_object_manipulation->cs_center = box_trafo.translation();
|
||||
}
|
||||
const Transform3d base_matrix = box_trafo;
|
||||
float space_size = 20.f *INV_ZOOM;
|
||||
|
||||
#if ENABLE_FIXED_GRABBER
|
||||
for (int i = 0; i < 3; ++i) {
|
||||
m_grabbers[i].matrix = base_matrix;
|
||||
}
|
||||
|
||||
const Vec3d zero = Vec3d::Zero();
|
||||
|
||||
// x axis
|
||||
m_grabbers[0].center = { box.max.x() + space_size, center.y(), center.z() };
|
||||
m_grabbers[0].center = {m_bounding_box.max.x() + space_size, 0, 0};
|
||||
// y axis
|
||||
m_grabbers[1].center = { center.x(), box.max.y() + space_size, center.z() };
|
||||
m_grabbers[1].center = {0, m_bounding_box.max.y() + space_size,0};
|
||||
// z axis
|
||||
m_grabbers[2].center = { center.x(), center.y(), box.max.z() + space_size };
|
||||
m_grabbers[2].center = {0,0, m_bounding_box.max.z() + space_size};
|
||||
|
||||
for (int i = 0; i < 3; ++i) {
|
||||
m_grabbers[i].color = AXES_COLOR[i];
|
||||
m_grabbers[i].hover_color = AXES_HOVER_COLOR[i];
|
||||
}
|
||||
#else
|
||||
// x axis
|
||||
m_grabbers[0].center = { box.max.x() + Offset, center.y(), center.z() };
|
||||
m_grabbers[0].color = AXES_COLOR[0];
|
||||
|
||||
// y axis
|
||||
m_grabbers[1].center = { center.x(), box.max.y() + Offset, center.z() };
|
||||
m_grabbers[1].color = AXES_COLOR[1];
|
||||
|
||||
// z axis
|
||||
m_grabbers[2].center = { center.x(), center.y(), box.max.z() + Offset };
|
||||
m_grabbers[2].color = AXES_COLOR[2];
|
||||
#endif
|
||||
|
||||
glsafe(::glLineWidth((m_hover_id != -1) ? 2.0f : 1.5f));
|
||||
|
||||
auto render_grabber_connection = [this, ¢er](unsigned int id) {
|
||||
auto render_grabber_connection = [this, &zero](unsigned int id) {
|
||||
if (m_grabbers[id].enabled) {
|
||||
//if (!m_grabber_connections[id].model.is_initialized() || !m_grabber_connections[id].old_center.isApprox(center)) {
|
||||
m_grabber_connections[id].old_center = center;
|
||||
m_grabber_connections[id].old_center = m_grabbers[id].center;
|
||||
m_grabber_connections[id].model.reset();
|
||||
|
||||
GLModel::Geometry init_data;
|
||||
@@ -166,7 +175,7 @@ void GLGizmoMove3D::on_render()
|
||||
init_data.reserve_indices(2);
|
||||
|
||||
// vertices
|
||||
init_data.add_vertex((Vec3f)center.cast<float>());
|
||||
init_data.add_vertex((Vec3f)zero.cast<float>());
|
||||
init_data.add_vertex((Vec3f)m_grabbers[id].center.cast<float>());
|
||||
|
||||
// indices
|
||||
@@ -186,7 +195,7 @@ void GLGizmoMove3D::on_render()
|
||||
if (shader != nullptr) {
|
||||
shader->start_using();
|
||||
const Camera& camera = wxGetApp().plater()->get_camera();
|
||||
shader->set_uniform("view_model_matrix", camera.get_view_matrix());
|
||||
shader->set_uniform("view_model_matrix", camera.get_view_matrix() * base_matrix);
|
||||
shader->set_uniform("projection_matrix", camera.get_projection_matrix());
|
||||
|
||||
// draw axes
|
||||
@@ -199,6 +208,28 @@ void GLGizmoMove3D::on_render()
|
||||
|
||||
// draw grabbers
|
||||
render_grabbers(box);
|
||||
|
||||
if (m_object_manipulation->is_instance_coordinates()) {
|
||||
shader = wxGetApp().get_shader("flat");
|
||||
if (shader != nullptr) {
|
||||
shader->start_using();
|
||||
const Camera& camera = wxGetApp().plater()->get_camera();
|
||||
|
||||
Geometry::Transformation cur_tran;
|
||||
if (auto mi = m_parent.get_selection().get_selected_single_intance()) {
|
||||
cur_tran = mi->get_transformation();
|
||||
} else {
|
||||
cur_tran = selection.get_first_volume()->get_instance_transformation();
|
||||
}
|
||||
|
||||
shader->set_uniform("view_model_matrix", camera.get_view_matrix() * cur_tran.get_matrix());
|
||||
shader->set_uniform("projection_matrix", camera.get_projection_matrix());
|
||||
|
||||
render_cross_mark(Vec3f::Zero(), true);
|
||||
|
||||
shader->stop_using();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void GLGizmoMove3D::on_register_raycasters_for_picking()
|
||||
@@ -245,5 +276,30 @@ double GLGizmoMove3D::calc_projection(const UpdateData& data) const
|
||||
|
||||
return projection;
|
||||
}
|
||||
|
||||
void GLGizmoMove3D::change_cs_by_selection() {
|
||||
int obejct_idx, volume_idx;
|
||||
ModelVolume *model_volume = m_parent.get_selection().get_selected_single_volume(obejct_idx, volume_idx);
|
||||
if (m_last_selected_obejct_idx == obejct_idx && m_last_selected_volume_idx == volume_idx) {
|
||||
return;
|
||||
}
|
||||
m_last_selected_obejct_idx = obejct_idx;
|
||||
m_last_selected_volume_idx = volume_idx;
|
||||
if (m_parent.get_selection().is_multiple_full_object()) {
|
||||
m_object_manipulation->set_use_object_cs(false);
|
||||
}
|
||||
else if (model_volume) {
|
||||
m_object_manipulation->set_use_object_cs(true);
|
||||
} else {
|
||||
m_object_manipulation->set_use_object_cs(false);
|
||||
}
|
||||
if (m_object_manipulation->get_use_object_cs()) {
|
||||
m_object_manipulation->set_coordinates_type(ECoordinatesType::Instance);
|
||||
} else {
|
||||
m_object_manipulation->set_coordinates_type(ECoordinatesType::World);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
} // namespace GUI
|
||||
} // namespace Slic3r
|
||||
|
||||
@@ -16,6 +16,8 @@ class GLGizmoMove3D : public GLGizmoBase
|
||||
static const double Offset;
|
||||
|
||||
Vec3d m_displacement{ Vec3d::Zero() };
|
||||
Vec3d m_center{ Vec3d::Zero() };
|
||||
BoundingBoxf3 m_bounding_box;
|
||||
double m_snap_step{ 1.0 };
|
||||
Vec3d m_starting_drag_position{ Vec3d::Zero() };
|
||||
Vec3d m_starting_box_center{ Vec3d::Zero() };
|
||||
@@ -57,6 +59,7 @@ protected:
|
||||
bool on_init() override;
|
||||
std::string on_get_name() const override;
|
||||
bool on_is_activable() const override;
|
||||
virtual void on_set_state() override;
|
||||
void on_start_dragging() override;
|
||||
void on_stop_dragging() override;
|
||||
void on_dragging(const UpdateData& data) override;
|
||||
@@ -68,6 +71,9 @@ protected:
|
||||
|
||||
private:
|
||||
double calc_projection(const UpdateData& data) const;
|
||||
void change_cs_by_selection(); //cs mean Coordinate System
|
||||
private:
|
||||
int m_last_selected_obejct_idx, m_last_selected_volume_idx;
|
||||
};
|
||||
|
||||
|
||||
|
||||
@@ -527,25 +527,6 @@ bool GLGizmoRotate3D::on_mouse(const wxMouseEvent &mouse_event)
|
||||
return use_grabbers(mouse_event);
|
||||
}
|
||||
|
||||
void GLGizmoRotate3D::data_changed(bool is_serializing) {
|
||||
const Selection &selection = m_parent.get_selection();
|
||||
bool is_wipe_tower = selection.is_wipe_tower();
|
||||
if (is_wipe_tower) {
|
||||
DynamicPrintConfig& config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
|
||||
float wipe_tower_rotation_angle =
|
||||
dynamic_cast<const ConfigOptionFloat *>(
|
||||
config.option("wipe_tower_rotation_angle"))
|
||||
->value;
|
||||
set_rotation(Vec3d(0., 0., (M_PI / 180.) * wipe_tower_rotation_angle));
|
||||
m_gizmos[0].disable_grabber();
|
||||
m_gizmos[1].disable_grabber();
|
||||
} else {
|
||||
set_rotation(Vec3d::Zero());
|
||||
m_gizmos[0].enable_grabber();
|
||||
m_gizmos[1].enable_grabber();
|
||||
}
|
||||
}
|
||||
|
||||
bool GLGizmoRotate3D::on_init()
|
||||
{
|
||||
for (GLGizmoRotate& g : m_gizmos)
|
||||
@@ -561,7 +542,57 @@ bool GLGizmoRotate3D::on_init()
|
||||
|
||||
std::string GLGizmoRotate3D::on_get_name() const
|
||||
{
|
||||
return _u8L("Rotate");
|
||||
if (!on_is_activable() && m_state == EState::Off) {
|
||||
return _u8L("Rotate") + ":\n" + _u8L("Please select at least one object.");
|
||||
} else {
|
||||
return _u8L("Rotate");
|
||||
}
|
||||
}
|
||||
|
||||
void GLGizmoRotate3D::on_set_state()
|
||||
{
|
||||
for (GLGizmoRotate &g : m_gizmos)
|
||||
g.set_state(m_state);
|
||||
if (get_state() == On) {
|
||||
m_object_manipulation->set_coordinates_type(ECoordinatesType::World);
|
||||
} else {
|
||||
m_last_volume = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
void GLGizmoRotate3D::data_changed(bool is_serializing) {
|
||||
const Selection &selection = m_parent.get_selection();
|
||||
const GLVolume * volume = selection.get_first_volume();
|
||||
if (volume == nullptr) {
|
||||
m_last_volume = nullptr;
|
||||
return;
|
||||
}
|
||||
if (m_last_volume != volume) {
|
||||
m_last_volume = volume;
|
||||
Geometry::Transformation tran;
|
||||
if (selection.is_single_full_instance()) {
|
||||
tran = volume->get_instance_transformation();
|
||||
} else {
|
||||
tran = volume->get_volume_transformation();
|
||||
}
|
||||
m_object_manipulation->set_init_rotation(tran);
|
||||
}
|
||||
|
||||
bool is_wipe_tower = selection.is_wipe_tower();
|
||||
if (is_wipe_tower) {
|
||||
DynamicPrintConfig& config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
|
||||
float wipe_tower_rotation_angle =
|
||||
dynamic_cast<const ConfigOptionFloat *>(
|
||||
config.option("wipe_tower_rotation_angle"))
|
||||
->value;
|
||||
set_rotation(Vec3d(0., 0., (M_PI / 180.) * wipe_tower_rotation_angle));
|
||||
m_gizmos[0].disable_grabber();
|
||||
m_gizmos[1].disable_grabber();
|
||||
} else {
|
||||
set_rotation(Vec3d::Zero());
|
||||
m_gizmos[0].enable_grabber();
|
||||
m_gizmos[1].enable_grabber();
|
||||
}
|
||||
}
|
||||
|
||||
bool GLGizmoRotate3D::on_is_activable() const
|
||||
|
||||
@@ -151,11 +151,9 @@ public:
|
||||
protected:
|
||||
bool on_init() override;
|
||||
std::string on_get_name() const override;
|
||||
void on_set_state() override {
|
||||
for (GLGizmoRotate& g : m_gizmos)
|
||||
g.set_state(m_state);
|
||||
}
|
||||
void on_set_hover_id() override {
|
||||
void on_set_state() override;
|
||||
void on_set_hover_id() override
|
||||
{
|
||||
for (int i = 0; i < 3; ++i)
|
||||
m_gizmos[i].set_hover_id((m_hover_id == i) ? 0 : -1);
|
||||
}
|
||||
@@ -179,7 +177,7 @@ protected:
|
||||
void on_render_input_window(float x, float y, float bottom_limit) override;
|
||||
|
||||
private:
|
||||
|
||||
const GLVolume *m_last_volume;
|
||||
class RotoptimzeWindow
|
||||
{
|
||||
ImGuiWrapper *m_imgui = nullptr;
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
|
||||
#include <GL/glew.h>
|
||||
|
||||
#include <wx/utils.h>
|
||||
#include <wx/utils.h>
|
||||
|
||||
namespace Slic3r {
|
||||
namespace GUI {
|
||||
@@ -24,11 +24,11 @@ Vec3d GetIntersectionOfRayAndPlane(Vec3d ray_position, Vec3d ray_dir, Vec3d plan
|
||||
//BBS: GUI refactor: add obj manipulation
|
||||
GLGizmoScale3D::GLGizmoScale3D(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id, GizmoObjectManipulation* obj_manipulation)
|
||||
: GLGizmoBase(parent, icon_filename, sprite_id)
|
||||
, m_scale(Vec3d::Ones())
|
||||
, m_offset(Vec3d::Zero())
|
||||
, m_snap_step(0.05)
|
||||
//BBS: GUI refactor: add obj manipulation
|
||||
, m_object_manipulation(obj_manipulation)
|
||||
, m_base_color(DEFAULT_BASE_COLOR)
|
||||
, m_drag_color(DEFAULT_DRAG_COLOR)
|
||||
, m_highlight_color(DEFAULT_HIGHLIGHT_COLOR)
|
||||
{
|
||||
m_grabber_connections[0].grabber_indices = { 0, 1 };
|
||||
m_grabber_connections[1].grabber_indices = { 2, 3 };
|
||||
@@ -39,6 +39,17 @@ GLGizmoScale3D::GLGizmoScale3D(GLCanvas3D& parent, const std::string& icon_filen
|
||||
m_grabber_connections[6].grabber_indices = { 9, 6 };
|
||||
}
|
||||
|
||||
const Vec3d &GLGizmoScale3D::get_scale()
|
||||
{
|
||||
if (m_object_manipulation) {
|
||||
Vec3d cache_scale = m_object_manipulation->get_cache().scale.cwiseQuotient(Vec3d(100,100,100));
|
||||
Vec3d temp_scale = cache_scale.cwiseProduct(m_scale);
|
||||
m_object_manipulation->limit_scaling_ratio(temp_scale);
|
||||
m_scale = temp_scale.cwiseQuotient(cache_scale);
|
||||
}
|
||||
return m_scale;
|
||||
}
|
||||
|
||||
std::string GLGizmoScale3D::get_tooltip() const
|
||||
{
|
||||
const Selection& selection = m_parent.get_selection();
|
||||
@@ -70,77 +81,57 @@ std::string GLGizmoScale3D::get_tooltip() const
|
||||
return "";
|
||||
}
|
||||
|
||||
static int constraint_id(int grabber_id)
|
||||
{
|
||||
static const std::vector<int> id_map = { 1, 0, 3, 2, 5, 4, 8, 9, 6, 7 };
|
||||
return (0 <= grabber_id && grabber_id < (int)id_map.size()) ? id_map[grabber_id] : -1;
|
||||
}
|
||||
|
||||
bool GLGizmoScale3D::on_mouse(const wxMouseEvent &mouse_event)
|
||||
{
|
||||
if (mouse_event.Dragging()) {
|
||||
if (m_dragging) {
|
||||
// Apply new temporary scale factors
|
||||
Selection& selection = m_parent.get_selection();
|
||||
TransformationType transformation_type;
|
||||
if (selection.is_single_full_instance()) {
|
||||
transformation_type.set_instance();
|
||||
} else if (selection.is_single_volume_or_modifier()) {
|
||||
if (wxGetApp().obj_manipul()->is_local_coordinates())
|
||||
transformation_type.set_local();
|
||||
}
|
||||
else if (wxGetApp().obj_manipul()->is_instance_coordinates())
|
||||
transformation_type.set_instance();
|
||||
|
||||
transformation_type.set_relative();
|
||||
|
||||
if (mouse_event.AltDown())
|
||||
transformation_type.set_independent();
|
||||
|
||||
selection.scale(m_scale, transformation_type);
|
||||
if (m_starting.ctrl_down && m_hover_id < 6) {
|
||||
// constrained scale:
|
||||
// uses the performed scale to calculate the new position of the constrained grabber
|
||||
// and from that calculates the offset (in world coordinates) to be applied to fullfill the constraint
|
||||
update_render_data();
|
||||
const Vec3d constraint_position = m_grabbers[constraint_id(m_hover_id)].center;
|
||||
// re-apply the scale because the selection always applies the transformations with respect to the initial state
|
||||
// set into on_start_dragging() with the call to selection.setup_cache()
|
||||
m_parent.get_selection().scale_and_translate(m_scale, m_starting.pivots[m_hover_id] - constraint_position, transformation_type);
|
||||
}
|
||||
Selection& selection = m_parent.get_selection();
|
||||
selection.scale_and_translate(get_scale(), get_offset(), transformation_type);
|
||||
}
|
||||
}
|
||||
return use_grabbers(mouse_event);
|
||||
}
|
||||
|
||||
void GLGizmoScale3D::data_changed(bool is_serializing)
|
||||
{
|
||||
const Selection &selection = m_parent.get_selection();
|
||||
bool enable_scale_xyz = selection.is_single_full_instance() ||
|
||||
selection.is_single_volume_or_modifier();
|
||||
for (unsigned int i = 0; i < 6; ++i)
|
||||
m_grabbers[i].enabled = enable_scale_xyz;
|
||||
|
||||
set_scale(Vec3d::Ones());
|
||||
|
||||
change_cs_by_selection();
|
||||
}
|
||||
|
||||
void GLGizmoScale3D::enable_ununiversal_scale(bool enable)
|
||||
{
|
||||
for (unsigned int i = 0; i < 6; ++i)
|
||||
m_grabbers[i].enabled = enable;
|
||||
}
|
||||
|
||||
void GLGizmoScale3D::data_changed(bool is_serializing) {
|
||||
const Selection &selection = m_parent.get_selection();
|
||||
bool enable_scale_xyz = selection.is_single_full_instance() ||
|
||||
selection.is_single_volume_or_modifier();
|
||||
for (unsigned int i = 0; i < 6; ++i)
|
||||
m_grabbers[i].enabled = enable_scale_xyz;
|
||||
|
||||
set_scale(Vec3d::Ones());
|
||||
}
|
||||
|
||||
bool GLGizmoScale3D::on_init()
|
||||
{
|
||||
for (int i = 0; i < 10; ++i) {
|
||||
for (int i = 0; i < 10; ++i)
|
||||
{
|
||||
m_grabbers.push_back(Grabber());
|
||||
}
|
||||
|
||||
double half_pi = 0.5 * (double)PI;
|
||||
|
||||
// x axis
|
||||
m_grabbers[0].angles(1) = half_pi;
|
||||
m_grabbers[1].angles(1) = half_pi;
|
||||
|
||||
// y axis
|
||||
m_grabbers[2].angles(0) = half_pi;
|
||||
m_grabbers[3].angles(0) = half_pi;
|
||||
|
||||
// BBS
|
||||
m_grabbers[4].enabled = false;
|
||||
@@ -151,7 +142,11 @@ bool GLGizmoScale3D::on_init()
|
||||
|
||||
std::string GLGizmoScale3D::on_get_name() const
|
||||
{
|
||||
return _u8L("Scale");
|
||||
if (!on_is_activable() && m_state == EState::Off) {
|
||||
return _u8L("Scale") + ":\n" + _u8L("Please select at least one object.");
|
||||
} else {
|
||||
return _u8L("Scale");
|
||||
}
|
||||
}
|
||||
|
||||
bool GLGizmoScale3D::on_is_activable() const
|
||||
@@ -160,21 +155,48 @@ bool GLGizmoScale3D::on_is_activable() const
|
||||
return !selection.is_empty() && !selection.is_wipe_tower();
|
||||
}
|
||||
|
||||
void GLGizmoScale3D::on_set_state() {
|
||||
if (get_state() == On) {
|
||||
m_last_selected_obejct_idx = -1;
|
||||
m_last_selected_volume_idx = -1;
|
||||
change_cs_by_selection();
|
||||
}
|
||||
}
|
||||
|
||||
static int constraint_id(int grabber_id)
|
||||
{
|
||||
static const std::vector<int> id_map = {1, 0, 3, 2, 5, 4, 8, 9, 6, 7};
|
||||
return (0 <= grabber_id && grabber_id < (int) id_map.size()) ? id_map[grabber_id] : -1;
|
||||
}
|
||||
|
||||
void GLGizmoScale3D::on_start_dragging()
|
||||
{
|
||||
assert(m_hover_id != -1);
|
||||
m_starting.drag_position = m_grabbers[m_hover_id].center;
|
||||
m_starting.plane_center = m_grabbers[4].center;
|
||||
m_starting.plane_nromal = m_grabbers[5].center - m_grabbers[4].center;
|
||||
m_starting.ctrl_down = wxGetKeyState(WXK_CONTROL);
|
||||
m_starting.box = m_box;
|
||||
if (m_hover_id != -1) {
|
||||
auto grabbers_transform = m_grabbers_tran.get_matrix();
|
||||
m_starting.drag_position = grabbers_transform * m_grabbers[m_hover_id].center;
|
||||
m_starting.plane_center = grabbers_transform * m_grabbers[4].center; // plane_center = bottom center
|
||||
m_starting.plane_nromal = (grabbers_transform * m_grabbers[5].center - grabbers_transform * m_grabbers[4].center).normalized();
|
||||
m_starting.ctrl_down = wxGetKeyState(WXK_CONTROL);
|
||||
m_starting.box = m_bounding_box;
|
||||
|
||||
m_starting.pivots[0] = m_grabbers[1].center;
|
||||
m_starting.pivots[1] = m_grabbers[0].center;
|
||||
m_starting.pivots[2] = m_grabbers[3].center;
|
||||
m_starting.pivots[3] = m_grabbers[2].center;
|
||||
m_starting.pivots[4] = m_grabbers[5].center;
|
||||
m_starting.pivots[5] = m_grabbers[4].center;
|
||||
m_starting.center = m_center;
|
||||
m_starting.instance_center = m_instance_center;
|
||||
|
||||
const Vec3d box_half_size = 0.5 * m_bounding_box.size();
|
||||
|
||||
m_starting.local_pivots[0] = Vec3d(box_half_size.x(), 0.0, -box_half_size.z());
|
||||
m_starting.local_pivots[1] = Vec3d(-box_half_size.x(), 0.0, -box_half_size.z());
|
||||
m_starting.local_pivots[2] = Vec3d(0.0, box_half_size.y(), -box_half_size.z());
|
||||
m_starting.local_pivots[3] = Vec3d(0.0, -box_half_size.y(), -box_half_size.z());
|
||||
m_starting.local_pivots[4] = Vec3d(0.0, 0.0, box_half_size.z());
|
||||
m_starting.local_pivots[5] = Vec3d(0.0, 0.0, -box_half_size.z());
|
||||
for (size_t i = 0; i < 6; i++) {
|
||||
m_starting.pivots[i] = grabbers_transform * m_starting.local_pivots[i]; // todo delete
|
||||
}
|
||||
m_starting.constraint_position = grabbers_transform * m_grabbers[constraint_id(m_hover_id)].center;
|
||||
m_scale = m_starting.scale = Vec3d::Ones() ;
|
||||
m_offset = Vec3d::Zero();
|
||||
}
|
||||
}
|
||||
|
||||
void GLGizmoScale3D::on_stop_dragging()
|
||||
@@ -185,26 +207,95 @@ void GLGizmoScale3D::on_stop_dragging()
|
||||
|
||||
void GLGizmoScale3D::on_dragging(const UpdateData& data)
|
||||
{
|
||||
if (m_hover_id == 0 || m_hover_id == 1)
|
||||
if ((m_hover_id == 0) || (m_hover_id == 1))
|
||||
do_scale_along_axis(X, data);
|
||||
else if (m_hover_id == 2 || m_hover_id == 3)
|
||||
else if ((m_hover_id == 2) || (m_hover_id == 3))
|
||||
do_scale_along_axis(Y, data);
|
||||
else if (m_hover_id == 4 || m_hover_id == 5)
|
||||
else if ((m_hover_id == 4) || (m_hover_id == 5))
|
||||
do_scale_along_axis(Z, data);
|
||||
else if (m_hover_id >= 6)
|
||||
do_scale_uniform(data);
|
||||
}
|
||||
|
||||
void GLGizmoScale3D::update_grabbers_data()
|
||||
{
|
||||
const Selection &selection = m_parent.get_selection();
|
||||
const auto &[box, box_trafo] = selection.get_bounding_box_in_current_reference_system();
|
||||
m_bounding_box = box;
|
||||
m_center = box_trafo.translation();
|
||||
m_grabbers_tran.set_matrix(box_trafo);
|
||||
m_instance_center = (selection.is_single_full_instance() || selection.is_single_volume_or_modifier()) ? selection.get_first_volume()->get_instance_offset() : m_center;
|
||||
|
||||
const Vec3d box_half_size = 0.5 * m_bounding_box.size();
|
||||
bool ctrl_down = wxGetKeyState(WXK_CONTROL);
|
||||
|
||||
|
||||
bool single_instance = selection.is_single_full_instance();
|
||||
bool single_volume = selection.is_single_modifier() || selection.is_single_volume();
|
||||
|
||||
// x axis
|
||||
m_grabbers[0].center = Vec3d(-(box_half_size.x()), 0.0, -box_half_size.z());
|
||||
m_grabbers[0].color = (ctrl_down && m_hover_id == 1) ? CONSTRAINED_COLOR : AXES_COLOR[0];
|
||||
m_grabbers[1].center = Vec3d(box_half_size.x(), 0.0, -box_half_size.z());
|
||||
m_grabbers[1].color = (ctrl_down && m_hover_id == 0) ? CONSTRAINED_COLOR : AXES_COLOR[0];
|
||||
// y axis
|
||||
m_grabbers[2].center = Vec3d(0.0, -(box_half_size.y()), -box_half_size.z());
|
||||
m_grabbers[2].color = (ctrl_down && m_hover_id == 3) ? CONSTRAINED_COLOR : AXES_COLOR[1];
|
||||
m_grabbers[3].center = Vec3d(0.0, box_half_size.y(), -box_half_size.z());
|
||||
m_grabbers[3].color = (ctrl_down && m_hover_id == 2) ? CONSTRAINED_COLOR : AXES_COLOR[1];
|
||||
// z axis do not show 4
|
||||
m_grabbers[4].center = Vec3d(0.0, 0.0, -(box_half_size.z()));
|
||||
m_grabbers[4].enabled = false;
|
||||
|
||||
m_grabbers[5].center = Vec3d(0.0, 0.0, box_half_size.z());
|
||||
m_grabbers[5].color = (ctrl_down && m_hover_id == 4) ? CONSTRAINED_COLOR : AXES_COLOR[2];
|
||||
// uniform
|
||||
m_grabbers[6].center = Vec3d(-box_half_size.x(), -box_half_size.y(), -box_half_size.z());
|
||||
m_grabbers[6].color = (ctrl_down && m_hover_id == 8) ? CONSTRAINED_COLOR : GRABBER_UNIFORM_COL;
|
||||
m_grabbers[7].center = Vec3d(box_half_size.x(), -box_half_size.y(), -box_half_size.z());
|
||||
m_grabbers[7].color = (ctrl_down && m_hover_id == 9) ? CONSTRAINED_COLOR : GRABBER_UNIFORM_COL;
|
||||
m_grabbers[8].center = Vec3d(box_half_size.x(), box_half_size.y(), -box_half_size.z());
|
||||
m_grabbers[8].color = (ctrl_down && m_hover_id == 6) ? CONSTRAINED_COLOR : GRABBER_UNIFORM_COL;
|
||||
m_grabbers[9].center = Vec3d(-box_half_size.x(), box_half_size.y(), -box_half_size.z());
|
||||
m_grabbers[9].color = (ctrl_down && m_hover_id == 7) ? CONSTRAINED_COLOR : GRABBER_UNIFORM_COL;
|
||||
for (int i = 0; i < 6; ++i) {
|
||||
//m_grabbers[i].color = AXES_COLOR[i / 2];
|
||||
m_grabbers[i].hover_color = AXES_HOVER_COLOR[i / 2];
|
||||
}
|
||||
for (int i = 6; i < 10; ++i) {
|
||||
//m_grabbers[i].color = GRABBER_UNIFORM_COL;
|
||||
m_grabbers[i].hover_color = GRABBER_UNIFORM_HOVER_COL;
|
||||
}
|
||||
|
||||
for (int i = 0; i < 10; ++i) {
|
||||
m_grabbers[i].matrix = m_grabbers_tran.get_matrix();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void GLGizmoScale3D::change_cs_by_selection() {
|
||||
int obejct_idx, volume_idx;
|
||||
ModelVolume *model_volume = m_parent.get_selection().get_selected_single_volume(obejct_idx, volume_idx);
|
||||
if (m_last_selected_obejct_idx == obejct_idx && m_last_selected_volume_idx == volume_idx) { return; }
|
||||
m_last_selected_obejct_idx = obejct_idx;
|
||||
m_last_selected_volume_idx = volume_idx;
|
||||
if (m_parent.get_selection().is_multiple_full_object()) {
|
||||
m_object_manipulation->set_coordinates_type(ECoordinatesType::World);
|
||||
} else if (model_volume) {
|
||||
m_object_manipulation->set_coordinates_type(ECoordinatesType::Local);
|
||||
}
|
||||
}
|
||||
|
||||
void GLGizmoScale3D::on_render()
|
||||
{
|
||||
glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
|
||||
glsafe(::glEnable(GL_DEPTH_TEST));
|
||||
|
||||
update_render_data();
|
||||
update_grabbers_data();
|
||||
|
||||
glsafe(::glLineWidth((m_hover_id != -1) ? 2.0f : 1.5f));
|
||||
|
||||
const float grabber_mean_size = (float) ((m_box.size().x() + m_box.size().y() + m_box.size().z()) / 3.0);
|
||||
const float grabber_mean_size = (float)((m_bounding_box.size().x() + m_bounding_box.size().y() + m_bounding_box.size().z()) / 3.0);
|
||||
|
||||
//draw connections
|
||||
GLShaderProgram* shader = wxGetApp().get_shader("flat");
|
||||
@@ -213,7 +304,7 @@ void GLGizmoScale3D::on_render()
|
||||
// BBS: when select multiple objects, uniform scale can be deselected, display the connection(4,5)
|
||||
//if (single_instance || single_volume) {
|
||||
const Camera& camera = wxGetApp().plater()->get_camera();
|
||||
shader->set_uniform("view_model_matrix", camera.get_view_matrix());
|
||||
shader->set_uniform("view_model_matrix", camera.get_view_matrix() * m_grabbers_tran.get_matrix());
|
||||
shader->set_uniform("projection_matrix", camera.get_projection_matrix());
|
||||
if (m_grabbers[4].enabled && m_grabbers[5].enabled)
|
||||
render_grabbers_connection(4, 5, m_grabbers[4].color);
|
||||
@@ -298,29 +389,53 @@ void GLGizmoScale3D::on_render_input_window(float x, float y, float bottom_limit
|
||||
void GLGizmoScale3D::do_scale_along_axis(Axis axis, const UpdateData& data)
|
||||
{
|
||||
double ratio = calc_ratio(data);
|
||||
if (ratio > 0.0) {
|
||||
Vec3d curr_scale = m_scale;
|
||||
curr_scale(axis) = m_starting.scale(axis) * ratio;
|
||||
m_scale = curr_scale;
|
||||
if (ratio > 0.0)
|
||||
{
|
||||
m_scale(axis) = m_starting.scale(axis) * ratio;
|
||||
if (m_starting.ctrl_down && abs(ratio-1.0f)>0.001) {
|
||||
double local_offset = 0.5 * (m_scale(axis) - m_starting.scale(axis)) * m_starting.box.size()(axis);
|
||||
if (m_hover_id == 2 * axis) {
|
||||
local_offset *= -1.0;
|
||||
}
|
||||
Vec3d local_offset_vec;
|
||||
switch (axis)
|
||||
{
|
||||
case X: { local_offset_vec = local_offset * Vec3d::UnitX(); break; }
|
||||
case Y: { local_offset_vec = local_offset * Vec3d::UnitY(); break;}
|
||||
case Z: { local_offset_vec = local_offset * Vec3d::UnitZ(); break;
|
||||
}
|
||||
default: break;
|
||||
}
|
||||
if (m_object_manipulation->is_world_coordinates()) {
|
||||
m_offset = local_offset_vec;
|
||||
} else {//if (m_object_manipulation->is_instance_coordinates())
|
||||
m_offset = m_grabbers_tran.get_matrix_no_offset() * local_offset_vec;
|
||||
}
|
||||
}
|
||||
else
|
||||
m_offset = Vec3d::Zero();
|
||||
}
|
||||
}
|
||||
|
||||
void GLGizmoScale3D::do_scale_uniform(const UpdateData & data)
|
||||
void GLGizmoScale3D::do_scale_uniform(const UpdateData& data)
|
||||
{
|
||||
const double ratio = calc_ratio(data);
|
||||
double ratio = calc_ratio(data);
|
||||
if (ratio > 0.0)
|
||||
{
|
||||
m_scale = m_starting.scale * ratio;
|
||||
m_offset = Vec3d::Zero();
|
||||
}
|
||||
}
|
||||
|
||||
double GLGizmoScale3D::calc_ratio(const UpdateData& data) const
|
||||
{
|
||||
double ratio = 0.0;
|
||||
|
||||
Vec3d pivot = (m_starting.ctrl_down && m_hover_id < 6) ? m_starting.pivots[m_hover_id] : m_starting.plane_center;
|
||||
|
||||
Vec3d pivot = (m_starting.ctrl_down && (m_hover_id < 6)) ? m_starting.constraint_position : m_starting.plane_center; // plane_center = bottom center
|
||||
Vec3d starting_vec = m_starting.drag_position - pivot;
|
||||
double len_starting_vec = starting_vec.norm();
|
||||
if (len_starting_vec != 0.0) {
|
||||
if (len_starting_vec != 0.0)
|
||||
{
|
||||
Vec3d mouse_dir = data.mouse_ray.unit_vector();
|
||||
Vec3d plane_normal = m_starting.plane_nromal;
|
||||
if (m_hover_id == 5) {
|
||||
@@ -328,10 +443,16 @@ double GLGizmoScale3D::calc_ratio(const UpdateData& data) const
|
||||
Vec3d plane_vec = mouse_dir.cross(m_starting.plane_nromal);
|
||||
plane_normal = plane_vec.cross(m_starting.plane_nromal);
|
||||
}
|
||||
|
||||
plane_normal = plane_normal.normalized();
|
||||
// finds the intersection of the mouse ray with the plane that the drag point moves
|
||||
// use ray-plane intersection see i.e. https://en.wikipedia.org/wiki/Line%E2%80%93plane_intersection
|
||||
Vec3d inters = GetIntersectionOfRayAndPlane(data.mouse_ray.a, mouse_dir, m_starting.drag_position, plane_normal.normalized());
|
||||
auto dot_value = (plane_normal.dot(mouse_dir));
|
||||
auto angle = Geometry::rad2deg(acos(dot_value));
|
||||
auto big_than_min_angle = abs(angle) < 95 && abs(angle) > 85;
|
||||
if (big_than_min_angle) {
|
||||
return 1;
|
||||
}
|
||||
Vec3d inters = GetIntersectionOfRayAndPlane(data.mouse_ray.a, mouse_dir, m_starting.drag_position, plane_normal);
|
||||
|
||||
Vec3d inters_vec = inters - m_starting.drag_position;
|
||||
|
||||
@@ -347,78 +468,5 @@ double GLGizmoScale3D::calc_ratio(const UpdateData& data) const
|
||||
return ratio;
|
||||
}
|
||||
|
||||
void GLGizmoScale3D::update_render_data()
|
||||
{
|
||||
|
||||
const Selection& selection = m_parent.get_selection();
|
||||
|
||||
bool single_instance = selection.is_single_full_instance();
|
||||
bool single_volume = selection.is_single_volume_or_modifier();
|
||||
|
||||
m_box.reset();
|
||||
m_transform = Transform3d::Identity();
|
||||
Vec3d angles = Vec3d::Zero();
|
||||
|
||||
if (single_instance) {
|
||||
// calculate bounding box in instance local reference system
|
||||
const Selection::IndicesList& idxs = selection.get_volume_idxs();
|
||||
for (unsigned int idx : idxs) {
|
||||
const GLVolume* vol = selection.get_volume(idx);
|
||||
m_box.merge(vol->bounding_box().transformed(vol->get_volume_transformation().get_matrix()));
|
||||
}
|
||||
|
||||
// gets transform from first selected volume
|
||||
const GLVolume* v = selection.get_first_volume();
|
||||
m_transform = v->get_instance_transformation().get_matrix();
|
||||
// gets angles from first selected volume
|
||||
angles = v->get_instance_rotation();
|
||||
}
|
||||
else if (single_volume) {
|
||||
const GLVolume* v = selection.get_first_volume();
|
||||
m_box = v->bounding_box();
|
||||
m_transform = v->world_matrix();
|
||||
angles = Geometry::extract_euler_angles(m_transform);
|
||||
}
|
||||
else
|
||||
m_box = selection.get_bounding_box();
|
||||
|
||||
const Vec3d& center = m_box.center();
|
||||
|
||||
// x axis
|
||||
m_grabbers[0].center = m_transform * Vec3d(m_box.min.x(), center.y(), m_box.min.z());
|
||||
m_grabbers[1].center = m_transform * Vec3d(m_box.max.x(), center.y(), m_box.min.z());
|
||||
|
||||
// y axis
|
||||
m_grabbers[2].center = m_transform * Vec3d(center.x(), m_box.min.y(), m_box.min.z());
|
||||
m_grabbers[3].center = m_transform * Vec3d(center.x(), m_box.max.y(), m_box.min.z());
|
||||
|
||||
// z axis do not show 4
|
||||
m_grabbers[4].center = m_transform * Vec3d(center.x(), center.y(), m_box.min.z());
|
||||
m_grabbers[4].enabled = false;
|
||||
|
||||
m_grabbers[5].center = m_transform * Vec3d(center.x(), center.y(), m_box.max.z());
|
||||
|
||||
// uniform
|
||||
m_grabbers[6].center = m_transform * Vec3d(m_box.min.x(), m_box.min.y(), m_box.min.z());
|
||||
m_grabbers[7].center = m_transform * Vec3d(m_box.max.x(), m_box.min.y(), m_box.min.z());
|
||||
m_grabbers[8].center = m_transform * Vec3d(m_box.max.x(), m_box.max.y(), m_box.min.z());
|
||||
m_grabbers[9].center = m_transform * Vec3d(m_box.min.x(), m_box.max.y(), m_box.min.z());
|
||||
|
||||
for (int i = 0; i < 6; ++i) {
|
||||
m_grabbers[i].color = AXES_COLOR[i/2];
|
||||
m_grabbers[i].hover_color = AXES_HOVER_COLOR[i/2];
|
||||
}
|
||||
|
||||
for (int i = 6; i < 10; ++i) {
|
||||
m_grabbers[i].color = GRABBER_UNIFORM_COL;
|
||||
m_grabbers[i].hover_color = GRABBER_UNIFORM_HOVER_COL;
|
||||
}
|
||||
|
||||
// sets grabbers orientation
|
||||
for (int i = 0; i < 10; ++i) {
|
||||
m_grabbers[i].angles = angles;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace GUI
|
||||
} // namespace Slic3r
|
||||
|
||||
@@ -19,25 +19,28 @@ class GLGizmoScale3D : public GLGizmoBase
|
||||
{
|
||||
Vec3d scale;
|
||||
Vec3d drag_position;
|
||||
Vec3d constraint_position;
|
||||
Vec3d center{Vec3d::Zero()};//sphere bounding box center
|
||||
Vec3d instance_center{Vec3d::Zero()};
|
||||
Vec3d plane_center; // keep the relative center position for scale in the bottom plane
|
||||
Vec3d plane_nromal; // keep the bottom plane
|
||||
Vec3d plane_nromal; // keep the bottom plane
|
||||
BoundingBoxf3 box;
|
||||
Vec3d pivots[6];
|
||||
Vec3d pivots[6];// Vec3d constraint_position{Vec3d::Zero()};
|
||||
Vec3d local_pivots[6];
|
||||
bool ctrl_down;
|
||||
|
||||
StartingData() : scale(Vec3d::Ones()), drag_position(Vec3d::Zero()), ctrl_down(false) { for (int i = 0; i < 5; ++i) { pivots[i] = Vec3d::Zero(); } }
|
||||
};
|
||||
|
||||
BoundingBoxf3 m_box;
|
||||
Transform3d m_transform;
|
||||
Vec3d m_scale{ Vec3d::Ones() };
|
||||
double m_snap_step{ 0.05 };
|
||||
mutable BoundingBoxf3 m_bounding_box;
|
||||
Geometry::Transformation m_grabbers_tran;//m_grabbers_transform
|
||||
Vec3d m_center{Vec3d::Zero()};
|
||||
Vec3d m_instance_center{Vec3d::Zero()};
|
||||
Vec3d m_scale;
|
||||
Vec3d m_offset;
|
||||
double m_snap_step;
|
||||
StartingData m_starting;
|
||||
|
||||
ColorRGBA m_base_color;
|
||||
ColorRGBA m_drag_color;
|
||||
ColorRGBA m_highlight_color;
|
||||
|
||||
struct GrabberConnection
|
||||
{
|
||||
GLModel model;
|
||||
@@ -58,9 +61,11 @@ public:
|
||||
double get_snap_step(double step) const { return m_snap_step; }
|
||||
void set_snap_step(double step) { m_snap_step = step; }
|
||||
|
||||
const Vec3d& get_scale() const { return m_scale; }
|
||||
const Vec3d &get_scale();
|
||||
void set_scale(const Vec3d& scale) { m_starting.scale = scale; m_scale = scale; }
|
||||
|
||||
const Vec3d& get_offset() const { return m_offset; }
|
||||
|
||||
std::string get_tooltip() const override;
|
||||
|
||||
/// <summary>
|
||||
@@ -76,6 +81,7 @@ protected:
|
||||
virtual bool on_init() override;
|
||||
virtual std::string on_get_name() const override;
|
||||
virtual bool on_is_activable() const override;
|
||||
virtual void on_set_state() override;
|
||||
virtual void on_start_dragging() override;
|
||||
virtual void on_stop_dragging() override;
|
||||
virtual void on_dragging(const UpdateData& data) override;
|
||||
@@ -92,7 +98,10 @@ private:
|
||||
void do_scale_uniform(const UpdateData& data);
|
||||
|
||||
double calc_ratio(const UpdateData& data) const;
|
||||
void update_render_data();
|
||||
void update_grabbers_data();
|
||||
void change_cs_by_selection(); // cs mean Coordinate System
|
||||
private:
|
||||
int m_last_selected_obejct_idx, m_last_selected_volume_idx;
|
||||
};
|
||||
|
||||
|
||||
|
||||
@@ -1024,20 +1024,6 @@ void GLGizmoText::show_tooltip_information(float x, float y)
|
||||
ImGui::PopStyleVar(2);
|
||||
}
|
||||
|
||||
ModelVolume *GLGizmoText::get_selected_single_volume(int &out_object_idx, int &out_volume_idx) const
|
||||
{
|
||||
if (m_parent.get_selection().is_single_volume() || m_parent.get_selection().is_single_modifier()) {
|
||||
const Selection &selection = m_parent.get_selection();
|
||||
const GLVolume * gl_volume = selection.get_first_volume();
|
||||
out_object_idx = gl_volume->object_idx();
|
||||
ModelObject *model_object = selection.get_model()->objects[out_object_idx];
|
||||
out_volume_idx = gl_volume->volume_idx();
|
||||
if (out_volume_idx < model_object->volumes.size())
|
||||
return model_object->volumes[out_volume_idx];
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void GLGizmoText::reset_text_info()
|
||||
{
|
||||
m_font_name = "";
|
||||
|
||||
@@ -62,7 +62,9 @@ std::vector<size_t> GLGizmosManager::get_selectable_idxs() const
|
||||
out.reserve(m_gizmos.size());
|
||||
if (m_parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView) {
|
||||
for (size_t i = 0; i < m_gizmos.size(); ++i)
|
||||
if (m_gizmos[i]->get_sprite_id() == (unsigned int) Measure ||
|
||||
if (m_gizmos[i]->get_sprite_id() == (unsigned int) Move ||
|
||||
m_gizmos[i]->get_sprite_id() == (unsigned int) Rotate ||
|
||||
m_gizmos[i]->get_sprite_id() == (unsigned int) Measure ||
|
||||
m_gizmos[i]->get_sprite_id() == (unsigned int) Assembly ||
|
||||
m_gizmos[i]->get_sprite_id() == (unsigned int) MmuSegmentation)
|
||||
out.push_back(i);
|
||||
@@ -247,6 +249,16 @@ bool GLGizmosManager::init_icon_textures()
|
||||
else
|
||||
return false;
|
||||
|
||||
if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/toolbar_reset_zero.svg", 14, 14, texture_id))
|
||||
icon_list.insert(std::make_pair((int) IC_TOOLBAR_RESET_ZERO, texture_id));
|
||||
else
|
||||
return false;
|
||||
|
||||
if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/toolbar_reset_zero_hover.svg", 14, 14, texture_id))
|
||||
icon_list.insert(std::make_pair((int) IC_TOOLBAR_RESET_ZERO_HOVER, texture_id));
|
||||
else
|
||||
return false;
|
||||
|
||||
if (IMTexture::load_from_svg_file(Slic3r::resources_dir() + "/images/toolbar_tooltip.svg", 25, 25, texture_id)) // ORCA: Use same resolution with gizmos to prevent blur on icon
|
||||
icon_list.insert(std::make_pair((int)IC_TOOLBAR_TOOLTIP, texture_id));
|
||||
else
|
||||
@@ -371,6 +383,9 @@ void GLGizmosManager::update_assemble_view_data()
|
||||
void GLGizmosManager::update_data()
|
||||
{
|
||||
if (!m_enabled) return;
|
||||
|
||||
const Selection& selection = m_parent.get_selection();
|
||||
|
||||
if (m_common_gizmos_data)
|
||||
m_common_gizmos_data->update(get_current()
|
||||
? get_current()->get_requirements()
|
||||
@@ -381,8 +396,10 @@ void GLGizmosManager::update_data()
|
||||
if (m_current != Flatten && !m_gizmos.empty()) m_gizmos[Flatten]->data_changed(m_serializing);
|
||||
|
||||
//BBS: GUI refactor: add object manipulation in gizmo
|
||||
m_object_manipulation.update_ui_from_settings();
|
||||
m_object_manipulation.UpdateAndShow(true);
|
||||
if (!selection.is_empty()) {
|
||||
m_object_manipulation.update_ui_from_settings();
|
||||
m_object_manipulation.UpdateAndShow(true);
|
||||
}
|
||||
}
|
||||
|
||||
bool GLGizmosManager::is_running() const
|
||||
@@ -461,6 +478,22 @@ bool GLGizmosManager::gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_p
|
||||
return false;
|
||||
}
|
||||
|
||||
bool GLGizmosManager::is_paint_gizmo()
|
||||
{
|
||||
return m_current == EType::FdmSupports ||
|
||||
m_current == EType::MmuSegmentation ||
|
||||
m_current == EType::Seam;
|
||||
}
|
||||
|
||||
bool GLGizmosManager::is_allow_select_all() {
|
||||
if (m_current == Undefined || m_current == EType::Move||
|
||||
m_current == EType::Rotate ||
|
||||
m_current == EType::Scale) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
ClippingPlane GLGizmosManager::get_clipping_plane() const
|
||||
{
|
||||
if (! m_common_gizmos_data
|
||||
|
||||
@@ -164,6 +164,8 @@ public:
|
||||
enum MENU_ICON_NAME {
|
||||
IC_TOOLBAR_RESET = 0,
|
||||
IC_TOOLBAR_RESET_HOVER,
|
||||
IC_TOOLBAR_RESET_ZERO,
|
||||
IC_TOOLBAR_RESET_ZERO_HOVER,
|
||||
IC_TOOLBAR_TOOLTIP,
|
||||
IC_TOOLBAR_TOOLTIP_HOVER,
|
||||
IC_NAME_COUNT,
|
||||
@@ -261,6 +263,8 @@ public:
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool is_paint_gizmo();
|
||||
bool is_allow_select_all();
|
||||
ClippingPlane get_clipping_plane() const;
|
||||
ClippingPlane get_assemble_view_clipping_plane() const;
|
||||
bool wants_reslice_supports_on_undo() const;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -4,6 +4,7 @@
|
||||
#include <memory>
|
||||
|
||||
#include "libslic3r/Point.hpp"
|
||||
#include "libslic3r/Geometry.hpp"
|
||||
#include <float.h>
|
||||
|
||||
#include "slic3r/GUI/GUI_Geometry.hpp"
|
||||
@@ -30,6 +31,8 @@ public:
|
||||
Vec3d position_rounded;
|
||||
Vec3d rotation;
|
||||
Vec3d rotation_rounded;
|
||||
Vec3d absolute_rotation;
|
||||
Vec3d absolute_rotation_rounded;
|
||||
Vec3d scale;
|
||||
Vec3d scale_rounded;
|
||||
Vec3d size;
|
||||
@@ -56,7 +59,7 @@ public:
|
||||
Cache m_cache;
|
||||
|
||||
bool m_imperial_units { false };
|
||||
|
||||
bool m_use_object_cs{false};
|
||||
// Mirroring buttons and their current state
|
||||
//enum MirrorButtonState {
|
||||
// mbHidden,
|
||||
@@ -75,19 +78,28 @@ public:
|
||||
std::string m_new_unit_string;
|
||||
Vec3d m_new_position;
|
||||
Vec3d m_new_rotation;
|
||||
Vec3d m_new_absolute_rotation;
|
||||
Vec3d m_new_scale;
|
||||
Vec3d m_new_size;
|
||||
Vec3d m_unscale_size;
|
||||
Vec3d m_buffered_position;
|
||||
Vec3d m_buffered_rotation;
|
||||
Vec3d m_buffered_absolute_rotation;
|
||||
Vec3d m_buffered_scale;
|
||||
Vec3d m_buffered_size;
|
||||
Vec3d cs_center;
|
||||
bool m_new_enabled {true};
|
||||
bool m_uniform_scale {true};
|
||||
ECoordinatesType m_coordinates_type{ ECoordinatesType::World };
|
||||
// Does the object manipulation panel work in World or Local coordinates?
|
||||
ECoordinatesType m_coordinates_type{ECoordinatesType::World};
|
||||
|
||||
bool m_show_reset_0_rotation{false};
|
||||
bool m_show_clear_rotation { false };
|
||||
bool m_show_clear_scale { false };
|
||||
bool m_show_drop_to_bed { false };
|
||||
enum class RotateType { None, Relative, Absolute
|
||||
};
|
||||
RotateType m_last_rotate_type{RotateType::None}; // 0:no input 1:relative 2:absolute
|
||||
|
||||
protected:
|
||||
float last_move_input_window_width = 0.0f;
|
||||
@@ -108,21 +120,33 @@ public:
|
||||
|
||||
void set_uniform_scaling(const bool uniform_scale);
|
||||
bool get_uniform_scaling() const { return m_uniform_scale; }
|
||||
void set_use_object_cs(bool flag){ if (m_use_object_cs != flag) m_use_object_cs = flag; }
|
||||
bool get_use_object_cs() { return m_use_object_cs; }
|
||||
// Does the object manipulation panel work in World or Local coordinates?
|
||||
void set_coordinates_type(ECoordinatesType type);
|
||||
ECoordinatesType get_coordinates_type() const { return m_coordinates_type; }
|
||||
bool is_world_coordinates() const { return m_coordinates_type == ECoordinatesType::World; }
|
||||
bool is_instance_coordinates() const { return m_coordinates_type == ECoordinatesType::Instance; }
|
||||
bool is_local_coordinates() const { return m_coordinates_type == ECoordinatesType::Local; }
|
||||
|
||||
void set_coordinates_type(ECoordinatesType type);
|
||||
ECoordinatesType get_coordinates_type() const;
|
||||
bool is_world_coordinates() const { return m_coordinates_type == ECoordinatesType::World; }
|
||||
bool is_instance_coordinates() const { return m_coordinates_type == ECoordinatesType::Instance; }
|
||||
bool is_local_coordinates() const { return m_coordinates_type == ECoordinatesType::Local; }
|
||||
|
||||
const Cache& get_cache() {return m_cache; }
|
||||
void reset_cache() { m_cache.reset(); }
|
||||
|
||||
void limit_scaling_ratio(Vec3d &scaling_factor) const;
|
||||
void on_change(const std::string& opt_key, int axis, double new_value);
|
||||
bool render_combo(ImGuiWrapper *imgui_wrapper, const std::string &label, const std::vector<std::string> &lines, size_t &selection_idx, float label_width, float item_width);
|
||||
void do_render_move_window(ImGuiWrapper *imgui_wrapper, std::string window_name, float x, float y, float bottom_limit);
|
||||
void do_render_rotate_window(ImGuiWrapper *imgui_wrapper, std::string window_name, float x, float y, float bottom_limit);
|
||||
void do_render_scale_input_window(ImGuiWrapper* imgui_wrapper, std::string window_name, float x, float y, float bottom_limit);
|
||||
float max_unit_size(int number, Vec3d &vec1, Vec3d &vec2,std::string str);
|
||||
bool reset_button(ImGuiWrapper *imgui_wrapper, float caption_max, float unit_size, float space_size, float end_text_size);
|
||||
bool reset_zero_button(ImGuiWrapper *imgui_wrapper, float caption_max, float unit_size, float space_size, float end_text_size);
|
||||
bool bbl_checkbox(const wxString &label, bool &value);
|
||||
|
||||
void show_move_tooltip_information(ImGuiWrapper *imgui_wrapper, float caption_max, float x, float y);
|
||||
void show_rotate_tooltip_information(ImGuiWrapper *imgui_wrapper, float caption_max, float x, float y);
|
||||
void show_scale_tooltip_information(ImGuiWrapper *imgui_wrapper, float caption_max, float x, float y);
|
||||
void set_init_rotation(const Geometry::Transformation &value);
|
||||
|
||||
private:
|
||||
void reset_settings_value();
|
||||
@@ -134,18 +158,24 @@ private:
|
||||
//Show or hide mirror buttons
|
||||
//void update_mirror_buttons_visibility();
|
||||
|
||||
// change values
|
||||
// change values
|
||||
void change_position_value(int axis, double value);
|
||||
void change_rotation_value(int axis, double value);
|
||||
void change_absolute_rotation_value(int axis, double value);
|
||||
void change_scale_value(int axis, double value);
|
||||
void change_size_value(int axis, double value);
|
||||
void do_scale(int axis, const Vec3d &scale) const;
|
||||
void reset_position_value();
|
||||
void reset_rotation_value();
|
||||
void reset_rotation_value(bool reset_relative);
|
||||
void reset_scale_value();
|
||||
|
||||
GLCanvas3D& m_glcanvas;
|
||||
unsigned int m_last_active_item { 0 };
|
||||
std::map<std::string, wxString> m_desc_move;
|
||||
std::map<std::string, wxString> m_desc_rotate;
|
||||
std::map<std::string, wxString> m_desc_scale;
|
||||
Vec3d m_init_rotation;
|
||||
Transform3d m_init_rotation_scale_tran;
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
Reference in New Issue
Block a user