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

Merge branch 'et_world_coordinates' into fs_emboss

Browse source 
# Conflicts:
#	src/libslic3r/Model.hpp
#	src/libslic3r/Technologies.hpp
#	src/slic3r/GUI/Gizmos/GLGizmoBase.hpp
This commit is contained in:
Filip Sykala 2022-04-20 12:13:17 +02:00
commit 7ec422d12f
19 changed files with 331 additions and 91 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
deps/OpenVDB/OpenVDB.cmake vendored
View file

@ -6,6 +6,13 @@ else()
set(_build_static ON)
endif()
set (_openvdb_vdbprint ON)
if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm")
# Build fails on raspberry pi due to missing link directive to latomic
# Let's hope it will be fixed soon.
set (_openvdb_vdbprint OFF)
endif ()
prusaslicer_add_cmake_project(OpenVDB
# 8.2 patched
URL https://github.com/tamasmeszaros/openvdb/archive/a68fd58d0e2b85f01adeb8b13d7555183ab10aa5.zip
@ -19,7 +26,7 @@ prusaslicer_add_cmake_project(OpenVDB
-DOPENVDB_CORE_STATIC=${_build_static}
-DOPENVDB_ENABLE_RPATH:BOOL=OFF
-DTBB_STATIC=${_build_static}
-DOPENVDB_BUILD_VDB_PRINT=ON
-DOPENVDB_BUILD_VDB_PRINT=${_openvdb_vdbprint}
-DDISABLE_DEPENDENCY_VERSION_CHECKS=ON # Centos6 has old zlib
)

5
src/libslic3r/Arrange.cpp
View file

@ -581,11 +581,6 @@ static void process_arrangeable(const ArrangePolygon &arrpoly,
const Vec2crd &offs = arrpoly.translation;
double rotation = arrpoly.rotation;
// This fixes:
// https://github.com/prusa3d/PrusaSlicer/issues/2209
if (p.points.size() < 3)
return;
outp.emplace_back(std::move(p));
outp.back().rotation(rotation);
outp.back().translation({offs.x(), offs.y()});

22
src/libslic3r/Format/SL1.cpp
View file

@ -503,21 +503,19 @@ static void write_thumbnail(Zipper &zipper, const ThumbnailData &data)
}
}
void SL1Archive::export_print(const std::string fname,
void SL1Archive::export_print(Zipper &zipper,
const SLAPrint &print,
const ThumbnailsList &thumbnails,
const std::string &prjname)
{
Zipper zipper{fname};
std::string project =
prjname.empty() ?
boost::filesystem::path(zipper.get_filename()).stem().string() :
prjname;
ConfMap iniconf, slicerconf;
fill_iniconf(iniconf, print);
iniconf["jobDir"] = project;
fill_slicerconf(slicerconf, print);
@ -527,13 +525,13 @@ void SL1Archive::export_print(const std::string fname,
zipper << to_ini(iniconf);
zipper.add_entry("prusaslicer.ini");
zipper << to_ini(slicerconf);
size_t i = 0;
for (const sla::EncodedRaster &rst : m_layers) {
std::string imgname = project + string_printf("%.5d", i++) + "." +
rst.extension();
zipper.add_entry(imgname.c_str(), rst.data(), rst.size());
}
@ -549,4 +547,14 @@ void SL1Archive::export_print(const std::string fname,
}
}
void SL1Archive::export_print(const std::string fname,
const SLAPrint &print,
const ThumbnailsList &thumbnails,
const std::string &prjname)
{
Zipper zipper{fname, Zipper::FAST_COMPRESSION};
export_print(zipper, print, thumbnails, prjname);
}
} // namespace Slic3r

7
src/libslic3r/Format/SL1.hpp
View file

@ -22,8 +22,13 @@ protected:
SLAPrinterConfig & cfg() { return m_cfg; }
const SLAPrinterConfig & cfg() const { return m_cfg; }
void export_print(Zipper &,
const SLAPrint &print,
const ThumbnailsList &thumbnails,
const std::string &projectname);
public:
SL1Archive() = default;
explicit SL1Archive(const SLAPrinterConfig &cfg): m_cfg(cfg) {}
explicit SL1Archive(SLAPrinterConfig &&cfg): m_cfg(std::move(cfg)) {}

10
src/libslic3r/Format/SL1_SVG.cpp
View file

@ -224,4 +224,14 @@ sla::RasterEncoder SL1_SVGArchive::get_encoder() const
return nullptr;
}
void SL1_SVGArchive::export_print(const std::string fname,
const SLAPrint &print,
const ThumbnailsList &thumbnails,
const std::string &projectname)
{
Zipper zipper{fname, Zipper::TIGHT_COMPRESSION};
SL1Archive::export_print(zipper, print, thumbnails, projectname);
}
} // namespace Slic3r

5
src/libslic3r/Format/SL1_SVG.hpp
View file

@ -14,6 +14,11 @@ protected:
public:
void export_print(const std::string fname,
const SLAPrint &print,
const ThumbnailsList &thumbnails,
const std::string &projectname = "") override;
using SL1Archive::SL1Archive;
};

5
src/libslic3r/Model.hpp
View file

@ -816,8 +816,7 @@ private:
}
// Providing a new mesh, therefore this volume will get a new unique ID assigned.
ModelVolume(ModelObject *object, const ModelVolume &other, TriangleMesh &&mesh) :
name(other.name), source(other.source), m_mesh(new TriangleMesh(std::move(mesh))),
config(other.config), m_type(other.m_type), object(object), m_transformation(other.m_transformation),
name(other.name), source(other.source), config(other.config), object(object), m_mesh(new TriangleMesh(std::move(mesh))), m_type(other.m_type), m_transformation(other.m_transformation),
text_configuration(other.text_configuration)
{
assert(this->id().valid());
@ -833,7 +832,7 @@ private:
assert(this->config.id() == other.config.id());
this->set_material_id(other.material_id());
this->config.set_new_unique_id();
if (mesh.facets_count() > 1)
if (m_mesh->facets_count() > 1)
calculate_convex_hull();
assert(this->config.id().valid());
assert(this->config.id() != other.config.id());

2
src/libslic3r/Technologies.hpp
View file

@ -89,6 +89,8 @@
#define ENABLE_PROCESS_G2_G3_LINES (1 && ENABLE_2_5_0_ALPHA1)
// Enable fix of used filament data exported to gcode file
#define ENABLE_USED_FILAMENT_POST_PROCESS (1 && ENABLE_2_5_0_ALPHA1)
// Enable gizmo grabbers to share common models
#define ENABLE_GIZMO_GRABBER_REFACTOR (1 && ENABLE_2_5_0_ALPHA1)
#endif // _prusaslicer_technologies_h_

157
src/slic3r/GUI/Gizmos/GLGizmoBase.cpp
View file

@ -18,10 +18,19 @@ const float GLGizmoBase::Grabber::SizeFactor = 0.05f;
const float GLGizmoBase::Grabber::MinHalfSize = 1.5f;
const float GLGizmoBase::Grabber::DraggingScaleFactor = 1.25f;
void GLGizmoBase::Grabber::render(bool hover, float size)
{
render(size, hover ? complementary(color) : color, false);
}
#if ENABLE_GIZMO_GRABBER_REFACTOR
GLModel GLGizmoBase::Grabber::s_cube;
GLModel GLGizmoBase::Grabber::s_cone;
GLGizmoBase::Grabber::~Grabber()
{
if (s_cube.is_initialized())
s_cube.reset();
if (s_cone.is_initialized())
s_cone.reset();
}
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
float GLGizmoBase::Grabber::get_half_size(float size) const
{
@ -41,29 +50,64 @@ void GLGizmoBase::Grabber::render(float size, const ColorRGBA& render_color, boo
return;
#endif // ENABLE_GL_SHADERS_ATTRIBUTES
if (!m_cube.is_initialized()) {
#if ENABLE_GIZMO_GRABBER_REFACTOR
if (!s_cube.is_initialized()) {
#else
if (!m_cube.is_initialized()) {
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
// This cannot be done in constructor, OpenGL is not yet
// initialized at that point (on Linux at least).
indexed_triangle_set its = its_make_cube(1., 1., 1.);
indexed_triangle_set its = its_make_cube(1.0, 1.0, 1.0);
its_translate(its, -0.5f * Vec3f::Ones());
#if ENABLE_LEGACY_OPENGL_REMOVAL
m_cube.init_from(its);
#else
m_cube.init_from(its, BoundingBoxf3{ { -0.5, -0.5, -0.5 }, { 0.5, 0.5, 0.5 } });
#if ENABLE_LEGACY_OPENGL_REMOVAL
#if ENABLE_GIZMO_GRABBER_REFACTOR
s_cube.init_from(its);
#else
m_cube.init_from(its);
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
#else
#if ENABLE_GIZMO_GRABBER_REFACTOR
s_cube.init_from(its, BoundingBoxf3{ { -0.5, -0.5, -0.5 }, { 0.5, 0.5, 0.5 } });
#else
m_cube.init_from(its, BoundingBoxf3{ { -0.5, -0.5, -0.5 }, { 0.5, 0.5, 0.5 } });
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
#endif // ENABLE_LEGACY_OPENGL_REMOVAL
}
const float fullsize = 2.0f * (dragging ? get_dragging_half_size(size) : get_half_size(size));
#if ENABLE_GIZMO_GRABBER_REFACTOR
if (!s_cone.is_initialized())
s_cone.init_from(its_make_cone(0.375, 1.5, double(PI) / 18.0));
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
#if ENABLE_GIZMO_GRABBER_REFACTOR
const float half_size = dragging ? get_dragging_half_size(size) : get_half_size(size);
#else
const float fullsize = 2.0f * (dragging ? get_dragging_half_size(size) : get_half_size(size));
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
#if ENABLE_LEGACY_OPENGL_REMOVAL
m_cube.set_color(render_color);
#else
m_cube.set_color(-1, render_color);
#if ENABLE_LEGACY_OPENGL_REMOVAL
#if ENABLE_GIZMO_GRABBER_REFACTOR
s_cube.set_color(render_color);
s_cone.set_color(render_color);
#else
m_cube.set_color(render_color);
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
#else
#if ENABLE_GIZMO_GRABBER_REFACTOR
s_cube.set_color(-1, render_color);
s_cone.set_color(-1, render_color);
#else
m_cube.set_color(-1, render_color);
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
#endif // ENABLE_LEGACY_OPENGL_REMOVAL
#if ENABLE_GL_SHADERS_ATTRIBUTES
const Camera& camera = wxGetApp().plater()->get_camera();
const Transform3d view_model_matrix = camera.get_view_matrix() * matrix * Geometry::assemble_transform(center, angles, fullsize * Vec3d::Ones());
#if ENABLE_GIZMO_GRABBER_REFACTOR
const Transform3d view_model_matrix = camera.get_view_matrix() * matrix * Geometry::assemble_transform(center, angles, 2.0 * half_size * Vec3d::Ones());
#else
const Transform3d view_model_matrix = camera.get_view_matrix() * matrix * Geometry::assemble_transform(center, angles, fullsize * Vec3d::Ones());
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
const Transform3d& projection_matrix = camera.get_projection_matrix();
shader->set_uniform("view_model_matrix", view_model_matrix);
@ -75,9 +119,86 @@ void GLGizmoBase::Grabber::render(float size, const ColorRGBA& render_color, boo
glsafe(::glRotated(Geometry::rad2deg(angles.z()), 0.0, 0.0, 1.0));
glsafe(::glRotated(Geometry::rad2deg(angles.y()), 0.0, 1.0, 0.0));
glsafe(::glRotated(Geometry::rad2deg(angles.x()), 1.0, 0.0, 0.0));
glsafe(::glScaled(fullsize, fullsize, fullsize));
#if ENABLE_GIZMO_GRABBER_REFACTOR
glsafe(::glScaled(2.0 * half_size, 2.0 * half_size, 2.0 * half_size));
#else
glsafe(::glScaled(fullsize, fullsize, fullsize));
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
#endif // ENABLE_GL_SHADERS_ATTRIBUTES
m_cube.render();
#if ENABLE_GIZMO_GRABBER_REFACTOR
s_cube.render();
#if ENABLE_GL_SHADERS_ATTRIBUTES
if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosX)) != 0) {
shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(Vec3d::UnitX(), Vec3d(0.0, 0.5 * double(PI), 0.0)));
s_cone.render();
}
if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegX)) != 0) {
shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(-Vec3d::UnitX(), Vec3d(0.0, -0.5 * double(PI), 0.0)));
s_cone.render();
}
if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosY)) != 0) {
shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(Vec3d::UnitY(), Vec3d(-0.5 * double(PI), 0.0, 0.0)));
s_cone.render();
}
if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegY)) != 0) {
shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(-Vec3d::UnitY(), Vec3d(0.5 * double(PI), 0.0, 0.0)));
s_cone.render();
}
if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosZ)) != 0) {
shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(Vec3d::UnitZ()));
s_cone.render();
}
if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegZ)) != 0) {
shader->set_uniform("view_model_matrix", view_model_matrix * Geometry::assemble_transform(-Vec3d::UnitZ(), Vec3d(double(PI), 0.0, 0.0)));
s_cone.render();
}
#else
if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosX)) != 0) {
glsafe(::glPushMatrix());
glsafe(::glTranslated(1.0, 0.0, 0.0));
glsafe(::glRotated(0.5 * Geometry::rad2deg(double(PI)), 0.0, 1.0, 0.0));
s_cone.render();
glsafe(::glPopMatrix());
}
if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegX)) != 0) {
glsafe(::glPushMatrix());
glsafe(::glTranslated(-1.0, 0.0, 0.0));
glsafe(::glRotated(-0.5 * Geometry::rad2deg(double(PI)), 0.0, 1.0, 0.0));
s_cone.render();
glsafe(::glPopMatrix());
}
if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosY)) != 0) {
glsafe(::glPushMatrix());
glsafe(::glTranslated(0.0, 1.0, 0.0));
glsafe(::glRotated(-0.5 * Geometry::rad2deg(double(PI)), 1.0, 0.0, 0.0));
s_cone.render();
glsafe(::glPopMatrix());
}
if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegY)) != 0) {
glsafe(::glPushMatrix());
glsafe(::glTranslated(0.0, -1.0, 0.0));
glsafe(::glRotated(0.5 * Geometry::rad2deg(double(PI)), 1.0, 0.0, 0.0));
s_cone.render();
glsafe(::glPopMatrix());
}
if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::PosZ)) != 0) {
glsafe(::glPushMatrix());
glsafe(::glTranslated(0.0, 0.0, 1.0));
s_cone.render();
glsafe(::glPopMatrix());
}
if ((int(extensions) & int(GLGizmoBase::EGrabberExtension::NegZ)) != 0) {
glsafe(::glPushMatrix());
glsafe(::glTranslated(0.0, 0.0, -1.0));
glsafe(::glRotated(Geometry::rad2deg(double(PI)), 1.0, 0.0, 0.0));
s_cone.render();
glsafe(::glPopMatrix());
}
#endif // ENABLE_GL_SHADERS_ATTRIBUTES
#else
m_cube.render();
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
#if !ENABLE_GL_SHADERS_ATTRIBUTES
glsafe(::glPopMatrix());
#endif // !ENABLE_GL_SHADERS_ATTRIBUTES

26
src/slic3r/GUI/Gizmos/GLGizmoBase.hpp
View file

@ -38,6 +38,19 @@ public:
// (254 is choosen to leave some space for forward compatibility)
static const unsigned int BASE_ID = 255 * 255 * 254;
#if ENABLE_GIZMO_GRABBER_REFACTOR
enum class EGrabberExtension
{
None = 0,
PosX = 1 << 0,
NegX = 1 << 1,
PosY = 1 << 2,
NegY = 1 << 3,
PosZ = 1 << 4,
NegZ = 1 << 5,
};
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
// Represents NO key(button on keyboard) value
static const int NO_SHORTCUT_KEY_VALUE = 0;
@ -56,10 +69,16 @@ protected:
Transform3d matrix{ Transform3d::Identity() };
#endif // ENABLE_GL_SHADERS_ATTRIBUTES
ColorRGBA color{ ColorRGBA::WHITE() };
#if ENABLE_GIZMO_GRABBER_REFACTOR
EGrabberExtension extensions{ EGrabberExtension::None };
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
Grabber() = default;
#if ENABLE_GIZMO_GRABBER_REFACTOR
~Grabber();
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
void render(bool hover, float size);
void render(bool hover, float size) { render(size, hover ? complementary(color) : color, false); }
void render_for_picking(float size) { render(size, color, true); }
float get_half_size(float size) const;
@ -68,7 +87,12 @@ protected:
private:
void render(float size, const ColorRGBA& render_color, bool picking);
#if ENABLE_GIZMO_GRABBER_REFACTOR
static GLModel s_cube;
static GLModel s_cone;
#else
GLModel m_cube;
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
};
public:

28
src/slic3r/GUI/Gizmos/GLGizmoMove.cpp
View file

@ -54,15 +54,25 @@ bool GLGizmoMove3D::on_mouse(const wxMouseEvent &mouse_event) {
}
void GLGizmoMove3D::data_changed() {
m_grabbers[2].enabled = !m_parent.get_selection().is_wipe_tower();
const Selection& selection = m_parent.get_selection();
bool is_wipe_tower = selection.is_wipe_tower();
m_grabbers[2].enabled = !is_wipe_tower;
}
bool GLGizmoMove3D::on_init()
{
for (int i = 0; i < 3; ++i) {
m_grabbers.push_back(Grabber());
#if ENABLE_GIZMO_GRABBER_REFACTOR
m_grabbers.back().extensions = GLGizmoBase::EGrabberExtension::PosZ;
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
}
#if ENABLE_GIZMO_GRABBER_REFACTOR
m_grabbers[0].angles = { 0.0, 0.5 * double(PI), 0.0 };
m_grabbers[1].angles = { -0.5 * double(PI), 0.0, 0.0 };
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
m_shortcut_key = WXK_CONTROL_M;
return true;
@ -133,8 +143,10 @@ void GLGizmoMove3D::on_dragging(const UpdateData& data)
void GLGizmoMove3D::on_render()
{
#if !ENABLE_GIZMO_GRABBER_REFACTOR
if (!m_cone.is_initialized())
m_cone.init_from(its_make_cone(1.0, 1.0, double(PI) / 18.0));
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
glsafe(::glEnable(GL_DEPTH_TEST));
@ -268,6 +280,7 @@ void GLGizmoMove3D::on_render()
// draw grabbers
#if ENABLE_WORLD_COORDINATE
render_grabbers(m_bounding_box);
#if !ENABLE_GIZMO_GRABBER_REFACTOR
for (unsigned int i = 0; i < 3; ++i) {
if (m_grabbers[i].enabled)
#if ENABLE_GL_SHADERS_ATTRIBUTES
@ -276,12 +289,15 @@ void GLGizmoMove3D::on_render()
render_grabber_extension((Axis)i, m_bounding_box, false);
#endif // ENABLE_GL_SHADERS_ATTRIBUTES
}
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
#else
render_grabbers(box);
#if !ENABLE_GIZMO_GRABBER_REFACTOR
for (unsigned int i = 0; i < 3; ++i) {
if (m_grabbers[i].enabled)
render_grabber_extension((Axis)i, box, false);
}
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
#endif // ENABLE_WORLD_COORDINATE
}
else {
@ -328,6 +344,7 @@ void GLGizmoMove3D::on_render()
m_grabbers[m_hover_id].render(true, mean_size);
shader->stop_using();
}
#if !ENABLE_GIZMO_GRABBER_REFACTOR
#if ENABLE_WORLD_COORDINATE
#if ENABLE_GL_SHADERS_ATTRIBUTES
render_grabber_extension((Axis)m_hover_id, base_matrix, m_bounding_box, false);
@ -337,6 +354,7 @@ void GLGizmoMove3D::on_render()
#else
render_grabber_extension((Axis)m_hover_id, box, false);
#endif // ENABLE_WORLD_COORDINATE
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
}
#if ENABLE_WORLD_COORDINATE
@ -362,21 +380,27 @@ void GLGizmoMove3D::on_render_for_picking()
#endif // ENABLE_GL_SHADERS_ATTRIBUTES
render_grabbers_for_picking(m_bounding_box);
#if ENABLE_GL_SHADERS_ATTRIBUTES
#if !ENABLE_GIZMO_GRABBER_REFACTOR
render_grabber_extension(X, base_matrix, m_bounding_box, true);
render_grabber_extension(Y, base_matrix, m_bounding_box, true);
render_grabber_extension(Z, base_matrix, m_bounding_box, true);
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
#else
#if !ENABLE_GIZMO_GRABBER_REFACTOR
render_grabber_extension(X, m_bounding_box, true);
render_grabber_extension(Y, m_bounding_box, true);
render_grabber_extension(Z, m_bounding_box, true);
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
glsafe(::glPopMatrix());
#endif // ENABLE_GL_SHADERS_ATTRIBUTES
#else
const BoundingBoxf3& box = m_parent.get_selection().get_bounding_box();
render_grabbers_for_picking(box);
#if !ENABLE_GIZMO_GRABBER_REFACTOR
render_grabber_extension(X, box, true);
render_grabber_extension(Y, box, true);
render_grabber_extension(Z, box, true);
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
#endif // ENABLE_WORLD_COORDINATE
}
@ -406,6 +430,7 @@ double GLGizmoMove3D::calc_projection(const UpdateData& data) const
return projection;
}
#if !ENABLE_GIZMO_GRABBER_REFACTOR
#if ENABLE_WORLD_COORDINATE && ENABLE_GL_SHADERS_ATTRIBUTES
void GLGizmoMove3D::render_grabber_extension(Axis axis, const Transform3d& base_matrix, const BoundingBoxf3& box, bool picking)
#else
@ -469,6 +494,7 @@ void GLGizmoMove3D::render_grabber_extension(Axis axis, const BoundingBoxf3& box
#endif // !ENABLE_LEGACY_OPENGL_REMOVAL
shader->stop_using();
}
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
#if ENABLE_WORLD_COORDINATE
#if ENABLE_GL_SHADERS_ATTRIBUTES

4
src/slic3r/GUI/Gizmos/GLGizmoMove.hpp
View file

@ -25,7 +25,9 @@ class GLGizmoMove3D : public GLGizmoBase
Vec3d m_starting_box_center{ Vec3d::Zero() };
Vec3d m_starting_box_bottom_center{ Vec3d::Zero() };
#if !ENABLE_GIZMO_GRABBER_REFACTOR
GLModel m_cone;
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
#if ENABLE_LEGACY_OPENGL_REMOVAL
struct GrabberConnection
{
@ -75,11 +77,13 @@ private:
#endif // ENABLE_GL_SHADERS_ATTRIBUTES
void calc_selection_box_and_center();
#endif // ENABLE_WORLD_COORDINATE
#if !ENABLE_GIZMO_GRABBER_REFACTOR
#if ENABLE_WORLD_COORDINATE && ENABLE_GL_SHADERS_ATTRIBUTES
void render_grabber_extension(Axis axis, const Transform3d& base_matrix, const BoundingBoxf3& box, bool picking);
#else
void render_grabber_extension(Axis axis, const BoundingBoxf3& box, bool picking);
#endif // ENABLE_WORLD_COORDINATE && ENABLE_GL_SHADERS_ATTRIBUTES
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
};

17
src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp
View file

@ -94,6 +94,9 @@ void GLGizmoRotate::disable_grabber() { m_grabbers[0].enabled = false; }
bool GLGizmoRotate::on_init()
{
m_grabbers.push_back(Grabber());
#if ENABLE_GIZMO_GRABBER_REFACTOR
m_grabbers.back().extensions = (GLGizmoBase::EGrabberExtension)(int(GLGizmoBase::EGrabberExtension::PosY) | int(GLGizmoBase::EGrabberExtension::NegY));
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
return true;
}
@ -149,15 +152,17 @@ void GLGizmoRotate::on_render()
if (!m_grabbers.front().enabled)
return;
#if !ENABLE_GIZMO_GRABBER_REFACTOR
if (!m_cone.is_initialized())
m_cone.init_from(its_make_cone(1.0, 1.0, double(PI) / 12.0));
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
const Selection& selection = m_parent.get_selection();
#if !ENABLE_WORLD_COORDINATE
const BoundingBoxf3& box = selection.get_bounding_box();
#endif // !ENABLE_WORLD_COORDINATE
if (m_hover_id != 0 && !m_grabbers[0].dragging) {
if (m_hover_id != 0 && !m_grabbers.front().dragging) {
#if ENABLE_WORLD_COORDINATE
init_data_from_selection(selection);
#else
@ -233,10 +238,14 @@ void GLGizmoRotate::on_render()
#if ENABLE_WORLD_COORDINATE
render_grabber(m_bounding_box);
#if !ENABLE_GIZMO_GRABBER_REFACTOR
render_grabber_extension(m_bounding_box, false);
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
#else
render_grabber(box);
#if !ENABLE_GIZMO_GRABBER_REFACTOR
render_grabber_extension(box, false);
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
#endif // ENABLE_WORLD_COORDINATE
#if !ENABLE_GL_SHADERS_ATTRIBUTES
@ -259,11 +268,15 @@ void GLGizmoRotate::on_render_for_picking()
#if ENABLE_WORLD_COORDINATE
render_grabbers_for_picking(m_bounding_box);
#if !ENABLE_GIZMO_GRABBER_REFACTOR
render_grabber_extension(m_bounding_box, true);
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
#else
const BoundingBoxf3& box = selection.get_bounding_box();
render_grabbers_for_picking(box);
#if !ENABLE_GIZMO_GRABBER_REFACTOR
render_grabber_extension(box, true);
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
#endif // ENABLE_WORLD_COORDINATE
#if !ENABLE_GL_SHADERS_ATTRIBUTES
@ -632,6 +645,7 @@ void GLGizmoRotate::render_grabber(const BoundingBoxf3& box)
render_grabbers(box);
}
#if !ENABLE_GIZMO_GRABBER_REFACTOR
void GLGizmoRotate::render_grabber_extension(const BoundingBoxf3& box, bool picking)
{
const float mean_size = float((box.size().x() + box.size().y() + box.size().z()) / 3.0);
@ -706,6 +720,7 @@ void GLGizmoRotate::render_grabber_extension(const BoundingBoxf3& box, bool pick
#endif // !ENABLE_LEGACY_OPENGL_REMOVAL
shader->stop_using();
}
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
#if ENABLE_GL_SHADERS_ATTRIBUTES
Transform3d GLGizmoRotate::local_transform(const Selection& selection) const

15
src/slic3r/GUI/Gizmos/GLGizmoRotate.hpp
View file

@ -29,17 +29,19 @@ private:
Axis m_axis;
double m_angle{ 0.0 };
Vec3d m_center{ Vec3d::Zero() };
float m_radius{ 0.0 };
float m_snap_coarse_in_radius{ 0.0 };
float m_snap_coarse_out_radius{ 0.0 };
float m_snap_fine_in_radius{ 0.0 };
float m_snap_fine_out_radius{ 0.0 };
float m_radius{ 0.0f };
float m_snap_coarse_in_radius{ 0.0f };
float m_snap_coarse_out_radius{ 0.0f };
float m_snap_fine_in_radius{ 0.0f };
float m_snap_fine_out_radius{ 0.0f };
#if ENABLE_WORLD_COORDINATE
BoundingBoxf3 m_bounding_box;
Transform3d m_orient_matrix{ Transform3d::Identity() };
#endif // ENABLE_WORLD_COORDINATE
#if !ENABLE_GIZMO_GRABBER_REFACTOR
GLModel m_cone;
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
#if ENABLE_LEGACY_OPENGL_REMOVAL
GLModel m_circle;
GLModel m_scale;
@ -59,6 +61,7 @@ private:
ColorRGBA m_drag_color;
ColorRGBA m_highlight_color;
public:
GLGizmoRotate(GLCanvas3D& parent, Axis axis);
virtual ~GLGizmoRotate() = default;
@ -110,7 +113,9 @@ private:
void render_angle() const;
#endif // ENABLE_LEGACY_OPENGL_REMOVAL
void render_grabber(const BoundingBoxf3& box);
#if !ENABLE_GIZMO_GRABBER_REFACTOR
void render_grabber_extension(const BoundingBoxf3& box, bool picking);
#endif // !ENABLE_GIZMO_GRABBER_REFACTOR
#if ENABLE_GL_SHADERS_ATTRIBUTES
Transform3d local_transform(const Selection& selection) const;

15
src/slic3r/GUI/Jobs/SLAImportDialog.hpp
View file

@ -54,6 +54,7 @@ public:
inp_choices.size(), inp_choices.data(), wxCB_READONLY | wxCB_DROPDOWN);
szchoices->Add(m_import_dropdown);
szchoices->AddStretchSpacer(1);
szchoices->Add(new wxStaticText(this, wxID_ANY, _L("Quality") + ": "), 0, wxALIGN_CENTER | wxALL, 5);
static const std::vector<wxString> qual_choices = {
@ -65,7 +66,7 @@ public:
m_quality_dropdown = new wxComboBox(
this, wxID_ANY, qual_choices[0], wxDefaultPosition, wxDefaultSize,
qual_choices.size(), qual_choices.data(), wxCB_READONLY | wxCB_DROPDOWN);
szchoices->Add(m_quality_dropdown);
szchoices->Add(m_quality_dropdown, 1);
m_import_dropdown->Bind(wxEVT_COMBOBOX, [this](wxCommandEvent &) {
if (get_selection() == Sel::profileOnly)
@ -73,14 +74,20 @@ public:
else m_quality_dropdown->Enable();
});
szvert->Add(szchoices, 0, wxALL, 5);
szvert->AddStretchSpacer(1);
szvert->Add(szchoices, 1, wxEXPAND | wxALL, 5);
auto szbtn = new wxBoxSizer(wxHORIZONTAL);
szbtn->Add(new wxButton{this, wxID_CANCEL});
szbtn->Add(new wxButton{this, wxID_CANCEL}, 0, wxRIGHT, 5);
szbtn->Add(new wxButton{this, wxID_OK});
szvert->Add(szbtn, 0, wxALIGN_RIGHT | wxALL, 5);
SetSizerAndFit(szvert);
wxGetApp().UpdateDlgDarkUI(this);
}
int ShowModal() override
{
CenterOnParent();
return wxDialog::ShowModal();
}
Sel get_selection() const override

1
src/slic3r/GUI/Jobs/SLAImportJob.cpp
View file

@ -139,6 +139,7 @@ void SLAImportJob::finalize(bool canceled, std::exception_ptr &eptr)
config += std::move(p->profile);
wxGetApp().preset_bundle->load_config_model(name, std::move(config));
p->plater->check_selected_presets_visibility(ptSLA);
wxGetApp().load_current_presets();
}

2
src/slic3r/GUI/MainFrame.cpp
View file

@ -1821,6 +1821,8 @@ bool MainFrame::load_config_file(const std::string &path)
show_error(this, ex.what());
return false;
}
m_plater->check_selected_presets_visibility(ptFFF);
wxGetApp().load_current_presets();
return true;
}

91
src/slic3r/GUI/Plater.cpp
View file

@ -2344,6 +2344,52 @@ std::string Plater::priv::get_config(const std::string &key) const
return wxGetApp().app_config->get(key);
}
// After loading of the presets from project, check if they are visible.
// Set them to visible if they are not.
void Plater::check_selected_presets_visibility(PrinterTechnology loaded_printer_technology)
{
auto update_selected_preset_visibility = [](PresetCollection& presets, std::vector<std::string>& names) {
if (!presets.get_selected_preset().is_visible) {
assert(presets.get_selected_preset().name == presets.get_edited_preset().name);
presets.get_selected_preset().is_visible = true;
presets.get_edited_preset().is_visible = true;
names.emplace_back(presets.get_selected_preset().name);
}
};
std::vector<std::string> names;
PresetBundle* preset_bundle = wxGetApp().preset_bundle;
if (loaded_printer_technology == ptFFF) {
update_selected_preset_visibility(preset_bundle->prints, names);
for (const std::string& filament : preset_bundle->filament_presets) {
Preset* preset = preset_bundle->filaments.find_preset(filament);
if (preset && !preset->is_visible) {
preset->is_visible = true;
names.emplace_back(preset->name);
if (preset->name == preset_bundle->filaments.get_edited_preset().name)
preset_bundle->filaments.get_selected_preset().is_visible = true;
}
}
}
else {
update_selected_preset_visibility(preset_bundle->sla_prints, names);
update_selected_preset_visibility(preset_bundle->sla_materials, names);
}
update_selected_preset_visibility(preset_bundle->printers, names);
preset_bundle->update_compatible(PresetSelectCompatibleType::Never);
// show notification about temporarily installed presets
if (!names.empty()) {
std::string notif_text = into_u8(_L_PLURAL("The preset below was temporarily installed on the active instance of PrusaSlicer",
"The presets below were temporarily installed on the active instance of PrusaSlicer", names.size())) + ":";
for (std::string& name : names)
notif_text += "\n - " + name;
get_notification_manager()->push_notification(NotificationType::CustomNotification,
NotificationManager::NotificationLevel::PrintInfoNotificationLevel, notif_text);
}
}
std::vector<size_t> Plater::priv::load_files(const std::vector<fs::path>& input_files, bool load_model, bool load_config, bool imperial_units/* = false*/)
{
if (input_files.empty()) { return std::vector<size_t>(); }
@ -2443,50 +2489,7 @@ std::vector<size_t> Plater::priv::load_files(const std::vector<fs::path>& input_
Preset::normalize(config);
PresetBundle* preset_bundle = wxGetApp().preset_bundle;
preset_bundle->load_config_model(filename.string(), std::move(config));
{
// After loading of the presets from project, check if they are visible.
// Set them to visible if they are not.
auto update_selected_preset_visibility = [](PresetCollection& presets, std::vector<std::string>& names) {
if (!presets.get_selected_preset().is_visible) {
assert(presets.get_selected_preset().name == presets.get_edited_preset().name);
presets.get_selected_preset().is_visible = true;
presets.get_edited_preset().is_visible = true;
names.emplace_back(presets.get_selected_preset().name);
}
};
std::vector<std::string> names;
if (loaded_printer_technology == ptFFF) {
update_selected_preset_visibility(preset_bundle->prints, names);
for (const std::string& filament : preset_bundle->filament_presets) {
Preset* preset = preset_bundle->filaments.find_preset(filament);
if (preset && !preset->is_visible) {
preset->is_visible = true;
names.emplace_back(preset->name);
if (preset->name == preset_bundle->filaments.get_edited_preset().name)
preset_bundle->filaments.get_selected_preset().is_visible = true;
}
}
}
else {
update_selected_preset_visibility(preset_bundle->sla_prints, names);
update_selected_preset_visibility(preset_bundle->sla_materials, names);
}
update_selected_preset_visibility(preset_bundle->printers, names);
preset_bundle->update_compatible(PresetSelectCompatibleType::Never);
// show notification about temporarily installed presets
if (!names.empty()) {
std::string notif_text = into_u8(_L_PLURAL("The preset below was temporarily installed on the active instance of PrusaSlicer",
"The presets below were temporarily installed on the active instance of PrusaSlicer", names.size())) + ":";
for (std::string& name : names)
notif_text += "\n - " + name;
notification_manager->push_notification(NotificationType::CustomNotification,
NotificationManager::NotificationLevel::PrintInfoNotificationLevel, notif_text);
}
}
q->check_selected_presets_visibility(loaded_printer_technology);
if (loaded_printer_technology == ptFFF)
CustomGCode::update_custom_gcode_per_print_z_from_config(model.custom_gcode_per_print_z, &preset_bundle->project_config);

1
src/slic3r/GUI/Plater.hpp
View file

@ -175,6 +175,7 @@ public:
std::vector<size_t> load_files(const std::vector<std::string>& input_files, bool load_model = true, bool load_config = true, bool imperial_units = false);
// to be called on drag and drop
bool load_files(const wxArrayString& filenames);
void check_selected_presets_visibility(PrinterTechnology loaded_printer_technology);
const wxString& get_last_loaded_gcode() const { return m_last_loaded_gcode; }