juli/OrcaSlicer
1
1
Fork 0
mirror of https://github.com/OrcaSlicer/OrcaSlicer.git synced 2026-09-16 13:32:44 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
2db770b672ca6fccfb9703796473968550722aed
OrcaSlicer/src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.cpp
T

4156 lines
215 KiB
C++
Raw Blame History

#include "GLGizmoTextureDisplacement.hpp"
#include <boost/log/trivial.hpp>
#include "libslic3r/MeshBoolean.hpp"
#include "libslic3r/Model.hpp"
#include "libslic3r/Utils.hpp"
#include "libslic3r/format.hpp"
#include "slic3r/GUI/Camera.hpp"
#include "slic3r/GUI/CameraUtils.hpp"
#include "slic3r/GUI/GLCanvas3D.hpp"
#include "slic3r/GUI/GLToolbar.hpp" // GLToolbar::Default_Icons_Size, to match the toolbar's icon size
#include "slic3r/GUI/GUI.hpp"
#include "slic3r/GUI/GUI_App.hpp"
#include "slic3r/GUI/GUI_ObjectList.hpp"
#include "slic3r/GUI/ImGuiWrapper.hpp"
#include "slic3r/GUI/MainFrame.hpp" // wxGetApp().mainframe, as the projector window's parent
#include "slic3r/GUI/MsgDialog.hpp"
#include "slic3r/GUI/OpenGLManager.hpp"
#include "slic3r/GUI/Plater.hpp"
#include "slic3r/GUI/TextureLibrary.hpp"
#include "slic3r/GUI/TextureProjectorFrame.hpp"
#include "slic3r/GUI/UVEditorCanvas.hpp"
#include "slic3r/GUI/Jobs/TextureDisplacementBakeJob.hpp"
#include "slic3r/GUI/Jobs/TextureDisplacementPreviewJob.hpp"
#include "slic3r/Utils/UndoRedo.hpp"
#include "GLGizmoUtils.hpp"
#include <glad/gl.h>
#include <algorithm>
#include <array>
#include <cmath>
#include <limits>
#include <queue>
#include <set>
namespace Slic3r::GUI {
namespace {
// ImGuiWrapper::slider_float()'s trailing `power` parameter is forwarded straight into
// ImGui::SliderFloat()'s ImGuiSliderFlags argument - this ImGui (1.83) replaced the old float
// "power" curve API with a flags word but kept the parameter in the same position, and
// ImGuiWrapper never caught up with the rename. Passing the Logarithmic flag through it is
// therefore how a log-scaled slider gets requested here.
//
// Depth and tile size both want it: they span two to three orders of magnitude, and the values
// that need the most precision (a few hundredths of a millimetre of relief, a very fine tile) are
// all bunched into the very bottom of a linear range, where a single pixel of slider travel is a
// bigger jump than the whole useful region.
constexpr float ImGuiLogSlider = float(ImGuiSliderFlags_Logarithmic);
// Uploads decoded 8-bit grayscale height data as an RGBA GPU texture for display in the panel.
// Shared by the per-layer thumbnail and the picker's library entries, which differ only in where
// their pixels came from.
//
// The source is downscaled to THUMBNAIL_MAX_PX first, with a box filter, and uploaded *without*
// mipmaps. Both halves of that matter, and together they are the fix for thumbnails rendering as
// garbage:
// - GLTexture's mipmap levels are not real downscales (see load_from_raw_data()'s header) - every
// level re-uploads the full-resolution buffer reinterpreted at a smaller size. A 512px texture
// drawn into a ~48px row is minified ~10x, which is exactly the regime where OpenGL picks those
// broken levels, so the thumbnail showed a scrambled crop of the image rather than the image.
// Turning mipmaps off makes it sample level 0, which is the real picture.
// - But level 0 at 512px sampled down to 48px with plain GL_LINEAR (a 2x2 tap) would alias badly
// on exactly the high-frequency patterns these textures are (knurl, hexagons, weave). Box-
// filtering down to roughly twice the displayed size first is what actually removes the
// frequencies that would alias, and it cuts the VRAM these hold by ~16x as a bonus.
constexpr int THUMBNAIL_MAX_PX = 128;
std::unique_ptr<GLTexture> upload_height_thumbnail(const DecodedHeightTexture &decoded)
{
if (decoded.empty())
return nullptr;
// Preserve aspect; never upscale a texture that is already small.
const int scale = std::max(1, (std::max(decoded.width, decoded.height) + THUMBNAIL_MAX_PX - 1) / THUMBNAIL_MAX_PX);
const int w = std::max(1, decoded.width / scale);
const int h = std::max(1, decoded.height / scale);
std::vector<unsigned char> rgba(size_t(w) * size_t(h) * 4);
for (int y = 0; y < h; ++y)
for (int x = 0; x < w; ++x) {
// Average the source block this destination pixel covers.
const int x0 = x * decoded.width / w, x1 = std::max(x0 + 1, (x + 1) * decoded.width / w);
const int y0 = y * decoded.height / h, y1 = std::max(y0 + 1, (y + 1) * decoded.height / h);
unsigned int sum = 0, n = 0;
for (int sy = y0; sy < y1 && sy < decoded.height; ++sy)
for (int sx = x0; sx < x1 && sx < decoded.width; ++sx, ++n)
sum += decoded.pixels[size_t(sy) * size_t(decoded.width) + size_t(sx)];
const unsigned char gray = (n > 0) ? static_cast<unsigned char>(sum / n) : 0;
const size_t di = (size_t(y) * size_t(w) + size_t(x)) * 4;
rgba[di + 0] = gray;
rgba[di + 1] = gray;
rgba[di + 2] = gray;
rgba[di + 3] = 255;
}
auto texture = std::make_unique<GLTexture>();
if (!texture->load_from_raw_data(std::move(rgba), (unsigned int) w, (unsigned int) h, false, /* use_mipmaps */ false))
return nullptr;
return texture;
}
// Intersects the camera ray through `mouse_pos` (screen coords) with the plane passing through
// `plane_point_local`/`plane_normal_local` (mesh-local coords, transformed to world by `trafo`).
// Returns false if the ray is parallel to the plane or the plane is behind the camera.
bool ray_plane_hit(const Camera &camera, const Vec2d &mouse_pos, const Transform3d &trafo,
const Vec3f &plane_point_local, const Vec3f &plane_normal_local, Vec3d &out_world_hit)
{
Vec3d ray_origin, ray_dir;
CameraUtils::ray_from_screen_pos(camera, mouse_pos, ray_origin, ray_dir);
const Vec3d plane_point_world = trafo * plane_point_local.cast<double>();
const Vec3d plane_normal_world = (trafo.matrix().block(0, 0, 3, 3).inverse().transpose() * plane_normal_local.cast<double>()).normalized();
const double denom = ray_dir.dot(plane_normal_world);
if (std::abs(denom) < 1e-8)
return false;
const double t = (plane_point_world - ray_origin).dot(plane_normal_world) / denom;
if (t < 0.0)
return false;
out_world_hit = ray_origin + ray_dir * t;
return true;
}
} // namespace
GLGizmoTextureDisplacement::GLGizmoTextureDisplacement(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id)
: GLGizmoPainterBase(parent, icon_filename, sprite_id)
{
}
bool GLGizmoTextureDisplacement::on_init()
{
m_desc["cursor_size"] = _L("Brush size");
m_desc["circle"] = _L("Circle");
m_desc["sphere"] = _L("Sphere");
m_desc["add_texture"] = _L("Add layer");
m_desc["remove_layer"] = _L("Remove");
m_desc["bake"] = _L("Bake");
m_desc["remove_all"] = _L("Erase all");
return true;
}
std::string GLGizmoTextureDisplacement::on_get_name() const
{
return _u8L("Texture displacement");
}
void GLGizmoTextureDisplacement::on_shutdown()
{
m_parent.toggle_model_objects_visibility(true);
m_preview_glmodel.reset();
m_bump_preview_glmodel.reset();
m_uvcheck_glmodel.reset();
m_wireframe_overlay_glmodel.reset();
m_wireframe_overlay_vcount = 0;
m_seam_glmodel.reset();
m_seam_hover_glmodel.reset();
m_seam_hover_edge = { -1, -1 };
m_seam_hover_vertex = -1;
m_seam_anchor_glmodel.reset();
m_seam_path_mode = false;
m_seam_path_anchor = -1;
m_subdivide_editing = false;
m_subdivide_preview_tris = -1;
m_subdivide_preview_glmodel.reset();
m_bump_active_chart = -1;
m_bump_active_vertex.clear();
m_bump_island_delta = Eigen::Matrix<float, 2, 3>::Identity();
m_island_drag_active = false;
m_island_move_set.clear();
m_adjust_texture_mode = false;
m_seam_edit_mode = false;
m_adjust_drag_handle = AdjustHandle::None;
m_adjust_anchor_valid = false;
// The pane is request-only: closing the gizmo drops the request, so reopening it later doesn't
// silently reopen the pane too.
m_show_uv_editor = false;
wxGetApp().plater()->show_uv_editor(false);
// Destroyed, not just hidden: unlike the UV pane (owned by Plater), this frame is owned here, and
// it holds a callback capturing `this`. Leaving it alive past the gizmo would leave that callback
// pointing at a gizmo that is no longer driving anything.
if (m_projector_frame != nullptr) {
m_projector_frame->Destroy();
m_projector_frame = nullptr;
}
m_projector_tex_source = nullptr; // a rebuilt frame starts with no texture in it
m_projector_tex_smoothing = -1.f;
}
PainterGizmoType GLGizmoTextureDisplacement::get_painter_type() const
{
return PainterGizmoType::TEXTURE_DISPLACEMENT;
}
wxString GLGizmoTextureDisplacement::handle_snapshot_action_name(bool shift_down, GLGizmoPainterBase::Button button_down) const
{
return shift_down ? _L("Erase texture displacement paint") : _L("Paint texture displacement");
}
void GLGizmoTextureDisplacement::render_painter_gizmo()
{
const Selection &selection = m_parent.get_selection();
glsafe(::glEnable(GL_BLEND));
glsafe(::glEnable(GL_DEPTH_TEST));
// Once anything is painted, m_preview_glmodel holds the true displaced result (same algorithm
// Bake uses). The untouched original topology (what render_triangles() draws) coincides
// exactly with it everywhere except the painted/displaced area, so both are drawn: the real
// preview geometry first, then the usual selection-highlight overlay with a small depth bias
// so it wins the depth test on the coincident (unpainted) surface - keeping the familiar
// enforcer/blocker highlight for precise brush editing there. Where the surface has actually
// been displaced, the raised preview geometry legitimately occludes the flat overlay - that
// visible bump is itself the "this is painted" indicator in that area.
//
// The bump preview is different: it never actually moves geometry (it's a shading trick), so
// its depth is identical to the overlay's *everywhere*, not just in the unpainted area - the
// depth-biased overlay would win the depth test across the whole surface and hide the bump
// shading entirely. So the overlay is skipped for it; the bump shading itself is the only
// feedback in that mode (still fine for painting, since render_cursor() below shows the brush).
// Coalesced bump rebuild from an in-progress UV island drag (see on_island_edited): done here, at
// most once per drawn frame, rather than synchronously in the UV canvas's mouse-move handler.
if (m_use_bump_preview && m_bump_preview_dirty) {
rebuild_bump_preview_mesh();
m_bump_preview_dirty = false;
}
const bool use_bump = m_use_bump_preview && m_bump_preview_glmodel.is_initialized();
// In Checker/Distortion mode the UV-check overlay *is* the surface visualization the user is
// looking at, so the opaque paint-selection highlight must not be drawn on top of it - same
// reasoning as skipping it for the bump preview (see bug #12). Without this the painted area
// covers the checker/heatmap and it can't be seen.
const bool show_paint_overlay = m_uv_check_mode == UVCheckMode::None;
if (use_bump) {
m_parent.toggle_model_objects_visibility(true);
if (ModelVolume *mv = texture_volume())
m_parent.toggle_model_objects_visibility(false, m_c->selection_info()->model_object(),
m_c->selection_info()->get_active_instance(), mv);
render_bump_preview_mesh();
} else if (m_preview_glmodel.is_initialized()) {
m_parent.toggle_model_objects_visibility(true);
if (ModelVolume *mv = texture_volume())
m_parent.toggle_model_objects_visibility(false, m_c->selection_info()->model_object(),
m_c->selection_info()->get_active_instance(), mv);
render_preview_mesh();
if (show_paint_overlay) {
glsafe(::glEnable(GL_POLYGON_OFFSET_FILL));
glsafe(::glPolygonOffset(-1.0f, -1.0f));
render_triangles(selection);
glsafe(::glDisable(GL_POLYGON_OFFSET_FILL));
}
} else if (show_paint_overlay) {
render_triangles(selection);
}
// Diagnostic overlays, drawn on top of whatever preview is active (both pull toward the camera
// with a polygon offset so they win the depth test against the coincident surface).
if (m_uv_check_mode != UVCheckMode::None)
render_uvcheck_mesh();
// While previewing a subdivision, its wireframe stands in for the mesh wireframe - it shows the
// density the model *would* have. The normal wireframe toggle is left untouched underneath, so it
// returns to whatever it was once the preview ends (which is what keeps an already-on wireframe on).
if (m_subdivide_editing)
render_subdivide_preview();
else if (m_wireframe_overlay)
render_wireframe_overlay();
// Marked seams are always shown for an LSCM layer, so existing cuts are visible before entering
// seam-edit mode - but they matter most while marking.
render_seam_overlay();
m_c->object_clipper()->render_cut();
m_c->instances_hider()->render_cut();
if (m_adjust_texture_mode)
render_adjust_texture_gizmo();
else if (!m_seam_edit_mode) // the brush cursor is meaningless while marking seams
render_cursor();
glsafe(::glDisable(GL_BLEND));
}
bool GLGizmoTextureDisplacement::on_mouse(const wxMouseEvent &mouse_event)
{
if (m_seam_edit_mode)
return on_mouse_seam(mouse_event);
if (m_adjust_texture_mode)
return on_mouse_adjust_texture(mouse_event);
return GLGizmoPainterBase::on_mouse(mouse_event);
}
bool GLGizmoTextureDisplacement::on_mouse_seam(const wxMouseEvent &mouse_event)
{
// Hold Ctrl to orbit/pan the camera while in seam mode, exactly as the base painter lets you do
// while painting: with Ctrl down we consume nothing, so the canvas gets the drag and moves the
// view. Without this, seam mode swallowed every left-drag and the camera couldn't be rotated.
if (mouse_event.CmdDown())
return false;
// Left-click marks/unmarks an edge; swallow the rest of the left-button stream so a drag doesn't
// paint, but let everything else through so the camera still orbits/pans/zooms normally.
if (mouse_event.LeftDown()) {
const Vec2d pos(mouse_event.GetX(), mouse_event.GetY());
if (m_seam_path_mode) {
// Two-click shortest-path seam: first click sets the start vertex, the next seams the whole
// path to it and becomes the new start (so a seam line chains click by click).
const int v = seam_vertex_at(pos);
if (v >= 0) {
if (m_seam_path_anchor < 0)
m_seam_path_anchor = v;
else {
mark_seam_path(m_seam_path_anchor, v);
m_seam_path_anchor = v;
}
rebuild_seam_anchor_overlay();
m_parent.set_as_dirty();
}
} else {
toggle_seam_at(pos);
}
return true;
}
// Live hover: highlight what a click would pick, so the clickable target is obvious (the "I don't
// know how it works" the user hit). In normal mode that is an edge; in shortest-path mode it is a
// vertex. Don't swallow the motion - the camera still needs it.
if (mouse_event.Moving()) {
const Vec2d pos(mouse_event.GetX(), mouse_event.GetY());
if (m_seam_path_mode) {
const int v = seam_vertex_at(pos);
if (v != m_seam_hover_vertex) {
m_seam_hover_vertex = v;
m_seam_hover_edge = { -1, -1 };
rebuild_seam_hover_overlay();
m_parent.set_as_dirty();
}
} else {
const std::pair<int, int> edge = seam_edge_at(pos);
if (edge != m_seam_hover_edge) {
m_seam_hover_edge = edge;
m_seam_hover_vertex = -1;
rebuild_seam_hover_overlay();
m_parent.set_as_dirty();
}
}
}
if (mouse_event.LeftUp() || (mouse_event.Dragging() && mouse_event.LeftIsDown()))
return true;
return false;
}
int GLGizmoTextureDisplacement::texture_volume_raycaster_index() const
{
const ModelVolume *mv = texture_volume();
const ModelObject *mo = m_c->selection_info()->model_object();
if (mv == nullptr || mo == nullptr)
return -1;
int idx = -1, count = 0;
for (const ModelVolume *v : mo->volumes) {
if (!v->is_model_part())
continue;
if (v == mv) { idx = count; break; }
++count;
}
return (idx >= 0 && idx < int(m_c->raycaster()->raycasters().size())) ? idx : -1;
}
std::pair<int, int> GLGizmoTextureDisplacement::seam_edge_at(const Vec2d &mouse_pos) const
{
const ModelVolume *mv = texture_volume();
const ModelObject *mo = m_c->selection_info()->model_object();
if (mv == nullptr || mo == nullptr)
return { -1, -1 };
const int idx = texture_volume_raycaster_index();
if (idx < 0)
return { -1, -1 };
const auto &raycasters = m_c->raycaster()->raycasters();
const Selection &selection = m_parent.get_selection();
const Transform3d trafo = mo->instances[selection.get_instance_idx()]->get_transformation().get_matrix() * mv->get_matrix();
const Camera &camera = wxGetApp().plater()->get_camera();
Vec3f hit = Vec3f::Zero(), normal = Vec3f::Zero();
size_t facet = 0;
if (!raycasters[size_t(idx)]->unproject_on_mesh(mouse_pos, trafo, camera, hit, normal,
m_c->object_clipper()->get_clipping_plane(), &facet))
return { -1, -1 };
const indexed_triangle_set &its = mv->mesh().its;
if (facet >= its.indices.size())
return { -1, -1 };
const stl_triangle_vertex_indices &tri = its.indices[facet];
// The facet edge nearest the hit point (point-to-segment distance in mesh space).
const auto seg_dist = [](const Vec3f &p, const Vec3f &a, const Vec3f &b) {
const Vec3f ab = b - a;
const float l2 = ab.squaredNorm();
const float t = (l2 > 1e-12f) ? std::clamp((p - a).dot(ab) / l2, 0.f, 1.f) : 0.f;
return (p - (a + ab * t)).norm();
};
int best_i = 0;
float best_d = std::numeric_limits<float>::max();
for (int i = 0; i < 3; ++i) {
const float d = seg_dist(hit, its.vertices[tri[i]], its.vertices[tri[(i + 1) % 3]]);
if (d < best_d) { best_d = d; best_i = i; }
}
const int a = tri[best_i], b = tri[(best_i + 1) % 3];
return { std::min(a, b), std::max(a, b) };
}
void GLGizmoTextureDisplacement::toggle_seam_at(const Vec2d &mouse_pos)
{
TextureDisplacementLayer *layer = active_layer();
if (layer == nullptr)
return;
const std::pair<int, int> edge = seam_edge_at(mouse_pos);
if (edge.first < 0)
return;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Mark texture seam"), UndoRedo::SnapshotType::GizmoAction);
auto &seams = layer->lscm_seam_edges;
if (const auto it = std::find(seams.begin(), seams.end(), edge); it != seams.end())
seams.erase(it);
else
seams.push_back(edge);
rebuild_preview();
}
int GLGizmoTextureDisplacement::seam_vertex_at(const Vec2d &mouse_pos) const
{
const ModelVolume *mv = texture_volume();
const ModelObject *mo = m_c->selection_info()->model_object();
if (mv == nullptr || mo == nullptr)
return -1;
const int idx = texture_volume_raycaster_index();
if (idx < 0)
return -1;
const auto &raycasters = m_c->raycaster()->raycasters();
const Selection &selection = m_parent.get_selection();
const Transform3d trafo = mo->instances[selection.get_instance_idx()]->get_transformation().get_matrix() * mv->get_matrix();
const Camera &camera = wxGetApp().plater()->get_camera();
Vec3f hit = Vec3f::Zero(), normal = Vec3f::Zero();
size_t facet = 0;
if (!raycasters[size_t(idx)]->unproject_on_mesh(mouse_pos, trafo, camera, hit, normal,
m_c->object_clipper()->get_clipping_plane(), &facet))
return -1;
const indexed_triangle_set &its = mv->mesh().its;
if (facet >= its.indices.size())
return -1;
const stl_triangle_vertex_indices &tri = its.indices[facet];
int best = tri[0];
float best_d = std::numeric_limits<float>::max();
for (int i = 0; i < 3; ++i) {
const float d = (hit - its.vertices[tri[i]]).squaredNorm();
if (d < best_d) { best_d = d; best = tri[i]; }
}
return best;
}
void GLGizmoTextureDisplacement::mark_seam_path(int v_from, int v_to)
{
TextureDisplacementLayer *layer = active_layer();
const ModelVolume *mv = texture_volume();
if (layer == nullptr || mv == nullptr || v_from < 0 || v_to < 0 || v_from == v_to)
return;
const indexed_triangle_set &its = mv->mesh().its;
const size_t n = its.vertices.size();
if (size_t(v_from) >= n || size_t(v_to) >= n)
return;
// Shortest path over the mesh's edge graph (Dijkstra, edge weight = length). Built on demand; one
// pass per click is fine even on a dense mesh.
std::vector<std::vector<std::pair<int, float>>> adj(n);
for (const stl_triangle_vertex_indices &tri : its.indices)
for (int i = 0; i < 3; ++i) {
const int a = tri[i], b = tri[(i + 1) % 3];
const float w = (its.vertices[size_t(a)] - its.vertices[size_t(b)]).norm();
adj[size_t(a)].push_back({ b, w });
adj[size_t(b)].push_back({ a, w });
}
std::vector<float> dist(n, std::numeric_limits<float>::infinity());
std::vector<int> prev(n, -1);
using QN = std::pair<float, int>;
std::priority_queue<QN, std::vector<QN>, std::greater<QN>> pq;
dist[size_t(v_from)] = 0.f;
pq.push({ 0.f, v_from });
while (!pq.empty()) {
const auto [d, u] = pq.top();
pq.pop();
if (d > dist[size_t(u)])
continue;
if (u == v_to)
break;
for (const auto &[w, ew] : adj[size_t(u)]) {
const float nd = d + ew;
if (nd < dist[size_t(w)]) {
dist[size_t(w)] = nd;
prev[size_t(w)] = u;
pq.push({ nd, w });
}
}
}
if (prev[size_t(v_to)] < 0)
return; // unreachable (disconnected components)
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Mark texture seam path"), UndoRedo::SnapshotType::GizmoAction);
auto &seams = layer->lscm_seam_edges;
for (int v = v_to; v != v_from && v >= 0; v = prev[size_t(v)]) {
const int p = prev[size_t(v)];
if (p < 0)
break;
const std::pair<int, int> e{ std::min(v, p), std::max(v, p) };
if (std::find(seams.begin(), seams.end(), e) == seams.end())
seams.push_back(e);
}
rebuild_preview();
}
void GLGizmoTextureDisplacement::rebuild_seam_anchor_overlay()
{
m_seam_anchor_glmodel.reset();
const ModelVolume *mv = texture_volume();
if (!m_seam_edit_mode || !m_seam_path_mode || mv == nullptr || m_seam_path_anchor < 0)
return;
const indexed_triangle_set &its = mv->mesh().its;
if (size_t(m_seam_path_anchor) >= its.vertices.size())
return;
// The anchor's incident edges, so the path's start vertex is visible on the model.
GLModel::Geometry init_data;
init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
unsigned nn = 0;
for (const stl_triangle_vertex_indices &tri : its.indices)
for (int i = 0; i < 3; ++i) {
const int a = tri[i], b = tri[(i + 1) % 3];
if (a == m_seam_path_anchor || b == m_seam_path_anchor) {
init_data.add_vertex(its.vertices[size_t(a)]);
init_data.add_vertex(its.vertices[size_t(b)]);
init_data.add_line(nn, nn + 1);
nn += 2;
}
}
if (!init_data.is_empty())
m_seam_anchor_glmodel.init_from(std::move(init_data));
}
void GLGizmoTextureDisplacement::rebuild_seam_hover_overlay()
{
m_seam_hover_glmodel.reset();
const ModelVolume *mv = texture_volume();
if (!m_seam_edit_mode || mv == nullptr)
return;
const indexed_triangle_set &its = mv->mesh().its;
GLModel::Geometry init_data;
init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
if (m_seam_path_mode) {
// Highlight the hovered vertex as its ring of incident edges, so the click target is legible on
// a dense mesh (matching the green anchor's style, in the hover yellow render_seam_overlay uses).
if (m_seam_hover_vertex < 0 || size_t(m_seam_hover_vertex) >= its.vertices.size())
return;
unsigned nn = 0;
for (const stl_triangle_vertex_indices &tri : its.indices)
for (int i = 0; i < 3; ++i) {
const int a = tri[i], b = tri[(i + 1) % 3];
if (a == m_seam_hover_vertex || b == m_seam_hover_vertex) {
init_data.add_vertex(its.vertices[size_t(a)]);
init_data.add_vertex(its.vertices[size_t(b)]);
init_data.add_line(nn, nn + 1);
nn += 2;
}
}
if (!init_data.is_empty())
m_seam_hover_glmodel.init_from(std::move(init_data));
return;
}
if (m_seam_hover_edge.first < 0 || size_t(m_seam_hover_edge.first) >= its.vertices.size() ||
size_t(m_seam_hover_edge.second) >= its.vertices.size())
return;
init_data.reserve_vertices(2);
init_data.reserve_indices(2);
init_data.add_vertex(its.vertices[size_t(m_seam_hover_edge.first)]);
init_data.add_vertex(its.vertices[size_t(m_seam_hover_edge.second)]);
init_data.add_line(0, 1);
m_seam_hover_glmodel.init_from(std::move(init_data));
}
void GLGizmoTextureDisplacement::rebuild_seam_overlay()
{
m_seam_glmodel.reset();
const ModelVolume *mv = texture_volume();
const TextureDisplacementLayer *layer = active_layer();
if (mv == nullptr || layer == nullptr || layer->lscm_seam_edges.empty())
return;
const indexed_triangle_set &its = mv->mesh().its;
GLModel::Geometry init_data;
init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
init_data.reserve_vertices(layer->lscm_seam_edges.size() * 2);
init_data.reserve_indices(layer->lscm_seam_edges.size() * 2);
unsigned n = 0;
for (const auto &[a, b] : layer->lscm_seam_edges) {
if (a < 0 || b < 0 || size_t(a) >= its.vertices.size() || size_t(b) >= its.vertices.size())
continue;
init_data.add_vertex(its.vertices[size_t(a)]);
init_data.add_vertex(its.vertices[size_t(b)]);
init_data.add_line(n, n + 1);
n += 2;
}
if (!init_data.is_empty())
m_seam_glmodel.init_from(std::move(init_data));
}
void GLGizmoTextureDisplacement::render_seam_overlay()
{
const ModelObject *mo = m_c->selection_info()->model_object();
const ModelVolume *mv = texture_volume();
const bool have_marked = m_seam_glmodel.is_initialized();
const bool have_hover = m_seam_edit_mode && m_seam_hover_glmodel.is_initialized();
const bool have_anchor = m_seam_edit_mode && m_seam_anchor_glmodel.is_initialized();
if (mo == nullptr || mv == nullptr || (!have_marked && !have_hover && !have_anchor))
return;
GLShaderProgram *shader = wxGetApp().get_shader("flat");
if (shader == nullptr)
return;
const Selection &selection = m_parent.get_selection();
const Transform3d trafo_matrix = mo->instances[selection.get_instance_idx()]->get_transformation().get_matrix() * mv->get_matrix();
const Camera &camera = wxGetApp().plater()->get_camera();
shader->start_using();
shader->set_uniform("view_model_matrix", camera.get_view_matrix() * trafo_matrix);
shader->set_uniform("projection_matrix", camera.get_projection_matrix());
glsafe(::glEnable(GL_POLYGON_OFFSET_LINE));
glsafe(::glPolygonOffset(-2.0f, -2.0f)); // pull further forward than the wireframe so seams read on top
// A seam edge is geometrically the same line as a wireframe edge, so a mere polygon offset is a
// fragile way to make the red seam beat the white wireframe - drivers apply GL_POLYGON_OFFSET_LINE
// inconsistently, and the two lines then z-fight and the wireframe wins. When the wireframe is on,
// or while actively marking, just draw the seams with depth testing off so they are unconditionally
// on top - being visible is the one thing this overlay has to guarantee.
const bool seams_on_top = m_wireframe_overlay || m_seam_edit_mode;
if (seams_on_top)
glsafe(::glDisable(GL_DEPTH_TEST));
#if !SLIC3R_OPENGL_ES
const bool wide = !OpenGLManager::get_gl_info().is_core_profile();
if (wide)
glsafe(::glLineWidth(4.0f));
#endif // !SLIC3R_OPENGL_ES
if (have_marked) {
m_seam_glmodel.set_color(ColorRGBA(1.0f, 0.15f, 0.15f, 1.0f)); // Blender's seam red
m_seam_glmodel.render();
}
// The edge a click would toggle, in yellow and pulled the furthest forward, so it is unmistakable
// which edge is being targeted while marking seams.
if (have_hover) {
glsafe(::glPolygonOffset(-3.0f, -3.0f));
m_seam_hover_glmodel.set_color(ColorRGBA(1.0f, 0.9f, 0.15f, 1.0f));
m_seam_hover_glmodel.render();
}
// The shortest-path start vertex, shown as its ring of incident edges in green.
if (have_anchor) {
glsafe(::glPolygonOffset(-3.0f, -3.0f));
m_seam_anchor_glmodel.set_color(ColorRGBA(0.2f, 1.0f, 0.4f, 1.0f));
m_seam_anchor_glmodel.render();
}
#if !SLIC3R_OPENGL_ES
if (wide)
glsafe(::glLineWidth(1.0f));
#endif // !SLIC3R_OPENGL_ES
glsafe(::glDisable(GL_POLYGON_OFFSET_LINE));
if (seams_on_top)
glsafe(::glEnable(GL_DEPTH_TEST));
shader->stop_using();
}
void GLGizmoTextureDisplacement::render_preview_mesh()
{
const ModelObject *mo = m_c->selection_info()->model_object();
const ModelVolume *mv = texture_volume();
if (mo == nullptr || mv == nullptr)
return;
const Selection &selection = m_parent.get_selection();
const Transform3d trafo_matrix = mo->instances[selection.get_instance_idx()]->get_transformation().get_matrix() * mv->get_matrix();
auto *shader = wxGetApp().get_shader("gouraud_light");
if (shader == nullptr)
return;
shader->start_using();
const Camera &camera = wxGetApp().plater()->get_camera();
const Transform3d &view_matrix = camera.get_view_matrix();
shader->set_uniform("view_model_matrix", view_matrix * trafo_matrix);
shader->set_uniform("projection_matrix", camera.get_projection_matrix());
const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * trafo_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
shader->set_uniform("view_normal_matrix", view_normal_matrix);
m_preview_glmodel.render();
shader->stop_using();
}
std::vector<Vec2f> GLGizmoTextureDisplacement::compute_layer_vertex_uvs(const indexed_triangle_set &patch,
const TextureDisplacementLayer &layer) const
{
if (layer.projection_method == TextureProjectionMethod::LSCM)
return compute_lscm_uvs(patch, layer); // one final uv per patch vertex (0 where unassigned)
if (layer.projection_method == TextureProjectionMethod::ViewProjected) {
std::vector<Vec2f> uv(patch.vertices.size());
for (size_t vi = 0; vi < patch.vertices.size(); ++vi) {
if (layer.view_project_projective) {
// Matches sample_layer_height()'s projective branch, including skipping
// apply_uv_transform(). A vertex behind the projector gets a uv far outside [0,1] so
// it samples as nothing, rather than the mirrored coordinate a blind divide gives.
if (!project_uv_projective(layer.view_project_matrix, patch.vertices[vi], uv[vi]))
uv[vi] = Vec2f(-1e6f, -1e6f);
continue;
}
const Vec2f planar(patch.vertices[vi].dot(layer.view_project_right),
patch.vertices[vi].dot(layer.view_project_up));
uv[vi] = apply_uv_transform(planar, layer);
}
return uv;
}
return {}; // Triplanar / Cylindrical / Spherical: the shader projects on its own
}
void GLGizmoTextureDisplacement::rebuild_bump_preview_mesh()
{
m_bump_preview_glmodel.reset();
const ModelVolume *mv = texture_volume();
if (mv == nullptr || m_triangle_selectors.empty())
return;
// Uses the *live* selector (not the flushed model facet data), so this reflects an in-progress
// stroke immediately rather than only once it ends - the point of this preview mode is to be
// the fast, no-CPU-meshing one.
const indexed_triangle_set patch = m_triangle_selectors[0]->get_facets_strict(EnforcerBlockerType::ENFORCER);
if (patch.indices.empty())
return;
const indexed_triangle_set &base = mv->mesh().its;
if (base.vertices.size() != patch.vertices.size())
return; // shouldn't happen: get_facets_strict() always returns the full vertex array
// Unpainted triangles, so the surrounding surface still renders (the render path hides the real
// model in bump mode). get_facets_strict() returns the same vertex array whatever state is asked.
const indexed_triangle_set rest = m_triangle_selectors[0]->get_facets_strict(EnforcerBlockerType::NONE);
// For LSCM we hand the shader the finished per-vertex texture uv (island placement + tiling/
// rotation/offset already folded in, exactly what the bake samples), because it cannot be
// reconstructed in the fragment shader the way a triplanar projection can. This is also what
// makes the fast preview follow the UV editor: the uvs move when an island is dragged, so this
// mesh rebuilds (on drag end) with them. The other projections keep projecting in-shader.
const TextureDisplacementLayer *active = active_layer();
std::vector<Vec2f> vertex_uv = active != nullptr ? compute_layer_vertex_uvs(patch, *active) : std::vector<Vec2f>{};
m_bump_preview_uses_vertex_uv = vertex_uv.size() == base.vertices.size();
if (!m_bump_preview_uses_vertex_uv)
vertex_uv.clear();
GLModel::Geometry init_data;
// P3N3T2: normal.x carries the paint weight, tex_coord the precomputed uv (see the vertex shader).
init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3T2 };
// Per-triangle weighting via a *flat* (unshared-vertex) mesh: every corner of a painted triangle
// gets weight 1, every corner of an unpainted one weight 0. This is what a coarse mesh needs - one
// painted face of a raw cube has no strictly-interior vertex (all 8 are shared), so per-vertex
// weighting would either bleed onto the neighbours (boundary weight 1) or vanish outright (boundary
// weight 0, which is what made a single face show nothing). Duplicating vertices costs no shading
// quality here because the bump shader takes its surface normal from screen-space derivatives of
// position (dFdx/dFdy), not from a per-vertex normal. normal.y flags the UV-editor island being
// dragged so the shader can move just that island via the island_delta uniform.
const bool have_active = m_bump_active_chart >= 0 && !m_bump_active_vertex.empty();
const size_t tri_total = patch.indices.size() + rest.indices.size();
init_data.reserve_vertices(tri_total * 3);
init_data.reserve_indices(tri_total * 3);
unsigned vcount = 0;
const auto emit_triangles = [&](const indexed_triangle_set &its, float weight) {
for (const stl_triangle_vertex_indices &tri : its.indices) {
for (int i = 0; i < 3; ++i) {
const int idx = tri[i];
const float act = (have_active && idx >= 0 && size_t(idx) < m_bump_active_vertex.size() &&
m_bump_active_vertex[size_t(idx)]) ? 1.f : 0.f;
const Vec2f uv = (weight > 0.5f && m_bump_preview_uses_vertex_uv && size_t(idx) < vertex_uv.size()) ?
vertex_uv[size_t(idx)] : Vec2f::Zero();
init_data.add_vertex(its.vertices[size_t(idx)], Vec3f(weight, act, 0.f), uv);
}
init_data.add_triangle(vcount, vcount + 1, vcount + 2);
vcount += 3;
}
};
emit_triangles(patch, 1.f); // painted -> bumped
emit_triangles(rest, 0.f); // untouched surface -> flat, so it still shows but isn't bumped
m_bump_preview_glmodel.init_from(std::move(init_data));
// GLModel::render() unconditionally re-sets the shader's "uniform_color" from this internal
// color field right before drawing (see GLModel.cpp) - setting the uniform manually in
// render_bump_preview_mesh() would just get overwritten by it, so it must be set here instead.
// GLModel::Geometry defaults to BLACK, which is exactly what showed up before this was added.
m_bump_preview_glmodel.set_color(GLVolume::NEUTRAL_COLOR);
// The mesh now reflects the islands' current placement, so any live drag delta is measured from
// here: reset it to identity and record the dragged island's baked transform.
m_bump_island_delta = Eigen::Matrix<float, 2, 3>::Identity();
const TextureDisplacementLayer *al = active_layer();
if (m_bump_active_chart >= 0 && al != nullptr) {
const std::vector<Eigen::Matrix<float, 2, 3>> xf = uv_editor_island_transforms(*al);
m_bump_baked_active_xf = (size_t(m_bump_active_chart) < xf.size()) ? xf[size_t(m_bump_active_chart)]
: Eigen::Matrix<float, 2, 3>::Identity();
} else {
m_bump_baked_active_xf = Eigen::Matrix<float, 2, 3>::Identity();
}
}
void GLGizmoTextureDisplacement::compute_bump_active_vertices(const std::vector<int> &charts)
{
m_bump_active_vertex.clear();
const ModelVolume *mv = texture_volume();
if (mv == nullptr || charts.empty())
return;
const PatchUnwrap &u = m_uv_editor_unwrap;
m_bump_active_vertex.assign(mv->mesh().its.vertices.size(), 0);
// Flag the base vertices of every chart being moved. For a group/multi move that is more than one
// chart, but since such a move is a pure translation the shader applies the same delta to them all
// (see on_island_edited) - exactly the "joined islands move together" behaviour.
for (size_t i = 0; i < u.uvs.size(); ++i) {
if (i >= u.vertex_chart.size() ||
std::find(charts.begin(), charts.end(), u.vertex_chart[i]) == charts.end())
continue;
const int sv = (i < u.source_vertex.size()) ? u.source_vertex[i] : -1;
if (sv >= 0 && size_t(sv) < m_bump_active_vertex.size())
m_bump_active_vertex[size_t(sv)] = 1;
}
}
int GLGizmoTextureDisplacement::island_group_of(const std::vector<int> &groups, int c)
{
return (c >= 0 && size_t(c) < groups.size() && groups[size_t(c)] >= 0) ? groups[size_t(c)] : c;
}
void GLGizmoTextureDisplacement::join_island_groups(std::vector<int> &groups, int a, int b, int chart_count)
{
if (a < 0 || b < 0 || chart_count <= 0)
return;
// Materialise to a full explicit table first, so singletons (which were implicit) get a concrete id
// that the relabel loop below can match on.
if (int(groups.size()) < chart_count) {
const size_t old = groups.size();
groups.resize(size_t(chart_count));
for (size_t i = old; i < groups.size(); ++i)
groups[i] = int(i);
}
for (size_t i = 0; i < groups.size(); ++i)
if (groups[i] < 0)
groups[i] = int(i);
const int ga = groups[size_t(a)], gb = groups[size_t(b)];
if (ga == gb)
return;
const int g = std::min(ga, gb);
for (int &x : groups)
if (x == ga || x == gb)
x = g;
}
std::vector<int> GLGizmoTextureDisplacement::build_island_move_set(const TextureDisplacementLayer &layer, int primary) const
{
std::vector<int> set;
const int chart_count = std::max(m_uv_editor_unwrap.chart_count, 0);
// Seed with the pane's multi-selection (falling back to just the primary if the canvas has none).
std::vector<int> seeds;
if (const UVEditorCanvas *canvas = wxGetApp().plater()->get_uv_editor_canvas())
seeds = canvas->selected_islands();
if (seeds.empty() && primary >= 0)
seeds.push_back(primary);
const auto add = [&set](int c) {
if (c >= 0 && std::find(set.begin(), set.end(), c) == set.end())
set.push_back(c);
};
for (int s : seeds) {
add(s);
// Pull in every chart sharing s's join group, so a joined pair moves as one.
const int gs = island_group_of(layer.island_groups, s);
for (int c = 0; c < chart_count; ++c)
if (island_group_of(layer.island_groups, c) == gs)
add(c);
}
add(primary); // never leave the primary out, whatever the selection state
return set;
}
void GLGizmoTextureDisplacement::render_bump_preview_mesh()
{
const ModelObject *mo = m_c->selection_info()->model_object();
const ModelVolume *mv = texture_volume();
if (mo == nullptr || mv == nullptr || !m_bump_preview_glmodel.is_initialized())
return;
const TextureDisplacementLayer *layer = active_layer();
if (layer == nullptr || layer->empty())
return;
// Reuses the layer-list panel's already-decoded, already-uploaded GPU thumbnail (smoothing-aware),
// whose grayscale value lives in the R channel exactly as the shader samples it. Its width/height
// are read straight off the texture - decoding the PNG here every frame would re-run the smoothing
// blur on every camera move, which is what tanked the frame rate at high smoothing.
GLTexture *tex = get_layer_thumbnail(*layer);
if (tex == nullptr || tex->get_width() <= 0 || tex->get_height() <= 0)
return;
GLShaderProgram *shader = wxGetApp().get_shader("texture_displacement_bump");
if (shader == nullptr)
return;
const Selection &selection = m_parent.get_selection();
const Transform3d trafo_matrix = mo->instances[selection.get_instance_idx()]->get_transformation().get_matrix() * mv->get_matrix();
const Camera &camera = wxGetApp().plater()->get_camera();
shader->start_using();
shader->set_uniform("view_model_matrix", camera.get_view_matrix() * trafo_matrix);
shader->set_uniform("projection_matrix", camera.get_projection_matrix());
shader->set_uniform("volume_world_matrix", trafo_matrix);
const ClippingPlaneDataWrapper clp_data = this->get_clipping_plane_data();
shader->set_uniform("clipping_plane", clp_data.clp_dataf);
shader->set_uniform("z_range", clp_data.z_range);
const Matrix3d view_normal_matrix =
camera.get_view_matrix().matrix().block(0, 0, 3, 3) * trafo_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
shader->set_uniform("view_normal_matrix", view_normal_matrix);
shader->set_uniform("volume_mirrored", trafo_matrix.matrix().determinant() < 0.0);
glsafe(::glActiveTexture(GL_TEXTURE0));
glsafe(::glBindTexture(GL_TEXTURE_2D, tex->get_id()));
shader->set_uniform("height_tex", 0);
shader->set_uniform("height_tex_texel", Vec2f(1.f / float(tex->get_width()), 1.f / float(tex->get_height())));
shader->set_uniform("depth_mm", layer->depth_mm);
shader->set_uniform("tiling_scale", layer->tiling_scale);
shader->set_uniform("rotation_rad", layer->rotation_deg * float(M_PI) / 180.f);
shader->set_uniform("uv_offset", layer->offset);
shader->set_uniform("invert", layer->invert);
// When set, the shader samples at the per-vertex uv baked into the mesh (LSCM) rather than
// projecting; see rebuild_bump_preview_mesh().
shader->set_uniform("use_vertex_uv", m_bump_preview_uses_vertex_uv);
// The live UV-editor island drag rides this 2x3 affine (identity except mid-drag); only the flagged
// island's vertices apply it, so a drag is a uniform update rather than a mesh rebuild.
const Eigen::Matrix<float, 2, 3> &d = m_bump_island_delta;
shader->set_uniform("island_delta_lin", std::array<float, 4>{ d(0, 0), d(0, 1), d(1, 0), d(1, 1) });
shader->set_uniform("island_delta_tr", Vec2f(d(0, 2), d(1, 2)));
m_bump_preview_glmodel.render();
glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
shader->stop_using();
}
void GLGizmoTextureDisplacement::rebuild_uvcheck_mesh()
{
m_uvcheck_glmodel.reset();
if (m_uv_check_mode == UVCheckMode::None)
return;
const ModelVolume *mv = texture_volume();
if (mv == nullptr || m_triangle_selectors.empty())
return;
const indexed_triangle_set patch = m_triangle_selectors[0]->get_facets_strict(EnforcerBlockerType::ENFORCER);
if (patch.indices.empty())
return;
const indexed_triangle_set &base = mv->mesh().its;
if (base.vertices.size() != patch.vertices.size())
return;
const TextureDisplacementLayer *layer = active_layer();
if (layer == nullptr)
return;
// The checker samples wherever the projection puts it; the projections the shader can't
// reconstruct (LSCM, ViewProjected) get a precomputed per-vertex uv, the rest project in-shader.
std::vector<Vec2f> uv = compute_layer_vertex_uvs(patch, *layer);
const bool have_uvs = uv.size() == base.vertices.size();
m_uvcheck_uses_vertex_uv = have_uvs;
// Per-vertex area distortion in [0,1] (0.5 == ideal), only when both requested and possible.
std::vector<float> distortion(base.vertices.size(), 0.5f);
if (m_uv_check_mode == UVCheckMode::Distortion && have_uvs) {
std::vector<float> tri_log(patch.indices.size(), 0.f);
for (size_t f = 0; f < patch.indices.size(); ++f) {
const stl_triangle_vertex_indices &t = patch.indices[f];
const float a3 = 0.5f * (base.vertices[t[1]] - base.vertices[t[0]]).cross(base.vertices[t[2]] - base.vertices[t[0]]).norm();
const Vec2f e0 = uv[t[1]] - uv[t[0]];
const Vec2f e1 = uv[t[2]] - uv[t[0]];
const float a2 = 0.5f * std::abs(e0.x() * e1.y() - e0.y() * e1.x());
tri_log[f] = (a3 > 1e-12f && a2 > 1e-12f) ? std::log2(a2 / a3) : 0.f;
}
// Centre the heatmap on the patch's own median stretch, so a globally-scaled unwrap reads as
// uniformly "ideal" and only *relative* stretching (the thing that matters) shows up as colour.
std::vector<float> sorted = tri_log;
float median = 0.f;
if (!sorted.empty()) {
std::nth_element(sorted.begin(), sorted.begin() + sorted.size() / 2, sorted.end());
median = sorted[sorted.size() / 2];
}
std::vector<float> sum(base.vertices.size(), 0.f);
std::vector<int> cnt(base.vertices.size(), 0);
for (size_t f = 0; f < patch.indices.size(); ++f) {
// +/- 2 stops (4x stretch either way) spans the full blue->red range.
const float d = std::clamp(0.5f + (tri_log[f] - median) / 4.f, 0.f, 1.f);
for (int k = 0; k < 3; ++k) {
sum[patch.indices[f][k]] += d;
++cnt[patch.indices[f][k]];
}
}
for (size_t v = 0; v < distortion.size(); ++v)
if (cnt[v] > 0)
distortion[v] = sum[v] / float(cnt[v]);
}
GLModel::Geometry init_data;
init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3T2 };
init_data.reserve_vertices(base.vertices.size());
init_data.reserve_indices(patch.indices.size() * 3);
for (size_t vi = 0; vi < base.vertices.size(); ++vi)
init_data.add_vertex(base.vertices[vi], Vec3f(distortion[vi], 0.f, 0.f),
have_uvs ? uv[vi] : Vec2f::Zero());
for (const stl_triangle_vertex_indices &tri : patch.indices)
init_data.add_triangle(unsigned(tri[0]), unsigned(tri[1]), unsigned(tri[2]));
m_uvcheck_glmodel.init_from(std::move(init_data));
}
void GLGizmoTextureDisplacement::render_uvcheck_mesh()
{
const ModelObject *mo = m_c->selection_info()->model_object();
const ModelVolume *mv = texture_volume();
if (mo == nullptr || mv == nullptr || !m_uvcheck_glmodel.is_initialized())
return;
const TextureDisplacementLayer *layer = active_layer();
if (layer == nullptr)
return;
GLShaderProgram *shader = wxGetApp().get_shader("texture_displacement_uvcheck");
if (shader == nullptr)
return;
const Selection &selection = m_parent.get_selection();
const Transform3d trafo_matrix = mo->instances[selection.get_instance_idx()]->get_transformation().get_matrix() * mv->get_matrix();
const Camera &camera = wxGetApp().plater()->get_camera();
shader->start_using();
shader->set_uniform("view_model_matrix", camera.get_view_matrix() * trafo_matrix);
shader->set_uniform("projection_matrix", camera.get_projection_matrix());
shader->set_uniform("volume_world_matrix", trafo_matrix);
const ClippingPlaneDataWrapper clp_data = this->get_clipping_plane_data();
shader->set_uniform("clipping_plane", clp_data.clp_dataf);
shader->set_uniform("z_range", clp_data.z_range);
const Matrix3d view_normal_matrix =
camera.get_view_matrix().matrix().block(0, 0, 3, 3) * trafo_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
shader->set_uniform("view_normal_matrix", view_normal_matrix);
shader->set_uniform("volume_mirrored", trafo_matrix.matrix().determinant() < 0.0);
shader->set_uniform("mode", m_uv_check_mode == UVCheckMode::Distortion ? 1 : 0);
shader->set_uniform("checker_freq", 4.f); // squares per texture tile
shader->set_uniform("tiling_scale", layer->tiling_scale);
shader->set_uniform("rotation_rad", layer->rotation_deg * float(M_PI) / 180.f);
shader->set_uniform("uv_offset", layer->offset);
shader->set_uniform("use_vertex_uv", m_uvcheck_uses_vertex_uv);
// Coincident with the base surface, so pull it toward the camera to win the depth test.
glsafe(::glEnable(GL_POLYGON_OFFSET_FILL));
glsafe(::glPolygonOffset(-1.0f, -1.0f));
m_uvcheck_glmodel.render();
glsafe(::glDisable(GL_POLYGON_OFFSET_FILL));
shader->stop_using();
}
void GLGizmoTextureDisplacement::build_wireframe_from_its(const indexed_triangle_set &its)
{
m_wireframe_overlay_glmodel.reset();
m_wireframe_overlay_vcount = its.vertices.size();
if (its.indices.empty())
return;
GLModel::Geometry init_data;
init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
init_data.reserve_vertices(its.vertices.size());
init_data.reserve_indices(its.indices.size() * 6);
for (const Vec3f &v : its.vertices)
init_data.add_vertex(v);
// One segment per triangle edge; shared edges drawn twice, harmless for a wireframe and far
// cheaper than deduplicating a million of them.
for (const stl_triangle_vertex_indices &tri : its.indices)
for (int i = 0; i < 3; ++i)
init_data.add_line(unsigned(tri[i]), unsigned(tri[(i + 1) % 3]));
if (!init_data.is_empty())
m_wireframe_overlay_glmodel.init_from(std::move(init_data));
}
void GLGizmoTextureDisplacement::rebuild_wireframe_overlay()
{
if (!m_wireframe_overlay) {
m_wireframe_overlay_glmodel.reset();
m_wireframe_overlay_vcount = 0;
return;
}
const ModelVolume *mv = texture_volume();
if (mv == nullptr)
return;
const indexed_triangle_set &its = mv->mesh().its;
if (its.indices.empty())
return;
// Building from the base mesh (bump/paint mode); its topology only changes on bake/subdivide, and
// this runs on every rebuild_preview(), so rebuild only when the vertex count actually changes.
if (m_wireframe_overlay_glmodel.is_initialized() && m_wireframe_overlay_vcount == its.vertices.size())
return;
build_wireframe_from_its(its);
}
void GLGizmoTextureDisplacement::refresh_wireframe()
{
if (!m_wireframe_overlay) {
m_wireframe_overlay_glmodel.reset();
m_wireframe_overlay_vcount = 0;
return;
}
// The wireframe has to sit on whatever mesh is actually on screen. In the true-displacement view
// that is the raised preview geometry (m_preview_its) - drawing the flat base mesh's edges there
// leaves them buried inside the bumps, which is why the wireframe "didn't show in real mode". In
// Fast (bump) mode or with nothing painted, the surface is the undisplaced base mesh.
if (!m_use_bump_preview && !m_preview_its.indices.empty())
build_wireframe_from_its(m_preview_its);
else
rebuild_wireframe_overlay();
}
void GLGizmoTextureDisplacement::render_wireframe_overlay()
{
const ModelObject *mo = m_c->selection_info()->model_object();
const ModelVolume *mv = texture_volume();
if (mo == nullptr || mv == nullptr || !m_wireframe_overlay_glmodel.is_initialized())
return;
GLShaderProgram *shader = wxGetApp().get_shader("flat");
if (shader == nullptr)
return;
const Selection &selection = m_parent.get_selection();
const Transform3d trafo_matrix = mo->instances[selection.get_instance_idx()]->get_transformation().get_matrix() * mv->get_matrix();
const Camera &camera = wxGetApp().plater()->get_camera();
shader->start_using();
shader->set_uniform("view_model_matrix", camera.get_view_matrix() * trafo_matrix);
shader->set_uniform("projection_matrix", camera.get_projection_matrix());
// Pull the lines toward the camera so they sit on the surface rather than z-fighting into it.
glsafe(::glEnable(GL_POLYGON_OFFSET_LINE));
glsafe(::glPolygonOffset(-1.0f, -1.0f));
m_wireframe_overlay_glmodel.set_color(ColorRGBA(1.0f, 1.0f, 1.0f, 0.6f)); // white, so it reads on any material
m_wireframe_overlay_glmodel.render();
glsafe(::glDisable(GL_POLYGON_OFFSET_LINE));
shader->stop_using();
}
void GLGizmoTextureDisplacement::rebuild_preview()
{
// Bumped first: any in-flight job's result (captured generation from before this call) will
// now compare unequal to m_preview_generation and be discarded when it completes, even if it
// finishes after the job queued below.
const uint64_t generation = ++m_preview_generation;
update_uv_editor();
rebuild_bump_preview_mesh();
rebuild_uvcheck_mesh();
rebuild_seam_overlay();
// The adaptive subdivision preview is driven by the painted area, so it has to follow the paint
// while it is open - a plain stroke changes which triangles would be refined. The uniform preview
// depends only on the mesh, so it is left to its own controls.
if (m_subdivide_editing && m_subdivide_adaptive)
rebuild_subdivide_preview();
const ModelVolume *mv = texture_volume();
if (mv == nullptr || !mv->is_texture_displacement_painted()) {
m_preview_glmodel.reset();
m_preview_its = indexed_triangle_set{}; // no displaced mesh; wireframe falls back to the base
refresh_wireframe();
return;
}
// In Fast/paint modes the wireframe follows the base mesh and can be built now; the true-displacement
// view's wireframe needs the displaced mesh, which only exists once the job below completes.
if (m_use_bump_preview)
refresh_wireframe();
TextureDisplacementPreviewInput input;
input.base_mesh = mv->mesh().its;
input.layers = mv->texture_displacement_layers;
input.options = mv->texture_displacement_options;
for (int i = 0; i < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++i)
input.facets_data[size_t(i)] = mv->texture_displacement_facet(i).get_data();
auto &worker = wxGetApp().plater()->get_ui_job_worker();
queue_job(worker, std::make_unique<TextureDisplacementPreviewJob>(std::move(input), generation,
[this](indexed_triangle_set its, uint64_t result_generation) {
if (result_generation != m_preview_generation)
return; // superseded by a newer edit while this was computing
m_preview_glmodel.reset();
if (!its.indices.empty()) {
m_preview_glmodel.init_from(its);
m_preview_glmodel.set_color(GLVolume::NEUTRAL_COLOR);
}
// Keep the displaced mesh so the wireframe overlay can be drawn on it (the true-displacement
// view), then refresh the wireframe from it.
m_preview_its = std::move(its);
refresh_wireframe();
m_parent.set_as_dirty();
}));
}
void GLGizmoTextureDisplacement::update_uv_editor()
{
Plater *plater = wxGetApp().plater();
UVEditorCanvas *uv_canvas = plater->get_uv_editor_canvas();
if (uv_canvas == nullptr)
return;
const ModelVolume *mv = texture_volume();
TextureDisplacementLayer *layer = active_layer();
// The pane is opened only on the user's explicit request (m_show_uv_editor), and only for an LSCM
// layer - never automatically just because something is painted. Keep the cached state/unwrap so
// that switching the toggle back on re-shows instantly (and re-solves if the paint changed while
// it was hidden, via the state comparison below).
if (!m_show_uv_editor || mv == nullptr || layer == nullptr ||
layer->projection_method != TextureProjectionMethod::LSCM) {
plater->show_uv_editor(false);
return;
}
// A vertex/edge edit committing (or an undo reverting one) changes the per-vertex UV overrides
// without going through the Unwrap button. Detect that and force a re-solve, so the pane's geometry
// stays in step with what will bake - the one exception to "only re-solve on Unwrap".
{
size_t sig = 1469598103934665603ull; // FNV-1a seed
const auto mix = [&sig](uint64_t x) { sig = (sig ^ x) * 1099511628211ull; };
mix(layer->lscm_uv_overrides.size());
for (const auto &[v, uv] : layer->lscm_uv_overrides) {
mix(uint64_t(uint32_t(v)));
mix(uint64_t(uint32_t(int32_t(std::llround(uv.x() * 1024.f)))));
mix(uint64_t(uint32_t(int32_t(std::llround(uv.y() * 1024.f)))));
}
if (sig != m_uv_overrides_sig) {
m_uv_overrides_sig = sig;
m_uv_unwrap_pending = true;
}
}
UVEditorState state;
state.slot = m_active_layer_slot;
state.image_data = layer->image_data.get();
state.seam_angle = layer->lscm_seam_angle_deg;
state.padding = layer->island_padding_mm;
state.facets = mv->texture_displacement_facet(m_active_layer_slot).get_data();
state.seam_edges = layer->lscm_seam_edges;
// The re-solve happens only when the user pressed "Unwrap" (m_uv_unwrap_pending). Every other call
// into here - a paint stroke ending, a slider release, the check mode changing - must not pay for
// a fresh LSCM solve; it just re-applies the cheap affine transforms over whatever unwrap already
// exists. If the paint changed underneath but the user hasn't asked to re-unwrap, the pane keeps
// showing the last unwrap on purpose (that is the whole point of making it an explicit action).
bool unwrap_changed = false;
if (m_uv_unwrap_pending) {
m_uv_unwrap_pending = false;
const indexed_triangle_set patch = extract_painted_patch(mv->mesh().its, state.facets);
if (patch.indices.empty()) {
m_uv_editor_state = UVEditorState{};
m_uv_editor_unwrap = PatchUnwrap{};
m_uv_editor_distortion_colors.clear();
plater->show_uv_editor(false);
return;
}
// Padding disabled (0): the user asked to pack islands with no gap between them.
m_uv_editor_unwrap = compute_patch_unwrap(patch, layer->lscm_seam_angle_deg, 0.f, layer->lscm_seam_edges);
// Re-apply any stored per-vertex UV edits onto the fresh unwrap, so the pane shows exactly what
// compute_lscm_uvs() will bake (which applies the same overrides). Keyed by mesh vertex, so every
// unwrapped copy of that vertex gets it - matching the bake's single-UV-per-vertex settle.
if (!layer->lscm_uv_overrides.empty()) {
std::map<int, Vec2f> ov;
for (const auto &[mv2, uv] : layer->lscm_uv_overrides)
ov[mv2] = uv;
for (size_t i = 0; i < m_uv_editor_unwrap.uvs.size(); ++i) {
const int sv = (i < m_uv_editor_unwrap.source_vertex.size()) ? m_uv_editor_unwrap.source_vertex[i] : -1;
const auto it = ov.find(sv);
if (it != ov.end())
m_uv_editor_unwrap.uvs[i] = it->second;
}
}
m_uv_editor_state = std::move(state);
unwrap_changed = true;
// Precompute the distortion heatmap now, while the patch is in hand - relative stretch doesn't
// change when islands are only moved, so this need not be redone on a drag. It is fed to the
// canvas below only while the Distortion check mode is on.
compute_uv_editor_distortion_colors(patch);
}
if (m_uv_editor_unwrap.empty()) {
// Nothing has been unwrapped yet (or the paint was cleared): keep the pane hidden until the user
// presses Unwrap. The panel shows a "Press Unwrap" hint in this state.
plater->show_uv_editor(false);
return;
}
// The pane background either mirrors the height texture (default) or shows a UV checker (#7), and is
// only re-uploaded when that choice, or the unwrap, actually changes - the height image is large.
const UVBackground desired_bg = (m_uv_check_mode == UVCheckMode::Checker) ? UVBackground::Checker : UVBackground::Height;
const bool bg_smoothing_changed = (desired_bg == UVBackground::Height) && (m_uv_editor_bg_smoothing != layer->smoothing);
if (unwrap_changed || desired_bg != m_uv_editor_bg || bg_smoothing_changed) {
m_uv_editor_bg_smoothing = layer->smoothing;
if (desired_bg == UVBackground::Checker) {
// An even squares-per-axis count so the pattern tiles seamlessly across the UV unit
// boundary (texcoord == position repeats it once per tile). Softened grays, not pure
// black/white, so it doesn't fight the island wires drawn over it.
constexpr int tex = 512, squares = 8, cell = tex / squares;
std::vector<unsigned char> checker(size_t(tex) * size_t(tex));
for (int y = 0; y < tex; ++y)
for (int x = 0; x < tex; ++x)
checker[size_t(y) * tex + x] = ((x / cell + y / cell) & 1) ? 205 : 70;
uv_canvas->set_background_texture(checker, tex, tex);
} else {
const DecodedHeightTexture height = decode_height_texture(*layer);
if (!height.empty())
uv_canvas->set_background_texture(height.pixels, height.width, height.height);
else
uv_canvas->set_background_texture({}, 0, 0);
}
m_uv_editor_bg = desired_bg;
}
// Grow (never shrink) the layer's island list to cover every chart. Shrinking would throw away a
// hand placement the moment a stroke temporarily merged two islands, and a stale extra entry is
// harmless - island_transform_matrix() only looks up the charts that actually exist.
if (layer->islands.size() < size_t(m_uv_editor_unwrap.chart_count))
layer->islands.resize(size_t(m_uv_editor_unwrap.chart_count));
// Connected-net layout (on by default): a *fresh* unwrap is unfolded so adjacent charts sit
// edge-to-edge (cube -> a net), rather than as separately packed squares. Only when the user pressed
// Unwrap (m_uv_apply_connected_net) - a re-segmentation renumbers charts anyway, so any hand
// placement from before is already meaningless. A *refresh* re-solve (a committed vertex edit, or an
// undo) must NOT relayout, or it would throw away every island placement on every vertex edit.
if (unwrap_changed && m_uv_apply_connected_net && layer->auto_connect_islands) {
std::vector<TextureIsland> net = compute_connected_net(m_uv_editor_unwrap);
if (net.size() == size_t(m_uv_editor_unwrap.chart_count)) {
if (layer->islands.size() < net.size())
layer->islands.resize(net.size());
for (size_t i = 0; i < net.size(); ++i)
layer->islands[i] = net[i];
}
}
if (unwrap_changed)
m_uv_apply_connected_net = false; // consumed; a refresh re-solve leaves placements alone
// The geometry goes over in the unwrap's *raw* mm coordinates and is only re-uploaded when the
// unwrap itself changed. Everything a slider or a drag can touch - island placement, tiling,
// rotation, offset - is an affine map on top of that, so it goes over as one 2x3 matrix per
// island instead. That is the whole reason dragging an island is now free: a patch of a million
// triangles has a million UVs to re-transform and re-upload otherwise, and it was doing exactly
// that on every single mouse-move event.
if (unwrap_changed) {
UVEditorCanvas::Islands view;
view.uvs = m_uv_editor_unwrap.uvs;
view.indices = m_uv_editor_unwrap.indices;
view.vertex_island = m_uv_editor_unwrap.vertex_chart;
view.boundary_edges = m_uv_editor_unwrap.boundary_edges;
view.island_count = m_uv_editor_unwrap.chart_count;
uv_canvas->set_island_edit_callback(
[this](int island, const Vec2f &offset_delta, float rotation_delta, float scale_factor, bool finished) {
on_island_edited(island, offset_delta, rotation_delta, scale_factor, finished);
});
uv_canvas->set_vertex_edit_callback(
[this](const std::vector<std::pair<int, Vec2f>> &edits) { on_uv_vertex_edited(edits); });
uv_canvas->set_command_callback([this](UVEditorCanvas::Command cmd) { on_uv_command(int(cmd)); });
uv_canvas->set_islands(std::move(view));
}
uv_canvas->set_select_mode(static_cast<UVEditorCanvas::SelectMode>(m_uv_select_mode));
uv_canvas->set_uv_transform(layer->tiling_scale, layer->rotation_deg, layer->tile_enabled,
layer->tile_method == TextureTileMethod::MirroredRepeat);
uv_canvas->set_island_transforms(uv_editor_island_transforms(*layer));
// The distortion heatmap tints the island fills only while its check mode is on; otherwise the
// canvas falls back to its default light-green wash.
if (m_uv_check_mode == UVCheckMode::Distortion)
uv_canvas->set_island_fill_colors(m_uv_editor_distortion_colors);
else
uv_canvas->set_island_fill_colors({});
plater->show_uv_editor(true);
}
void GLGizmoTextureDisplacement::compute_uv_editor_distortion_colors(const indexed_triangle_set &patch)
{
m_uv_editor_distortion_colors.clear();
const PatchUnwrap &u = m_uv_editor_unwrap;
if (u.empty() || u.chart_count <= 0)
return;
// log2(uv area / 3D area) per unwrap triangle - the same measure the 3D distortion overlay uses.
std::vector<float> tri_log(u.indices.size(), 0.f);
std::vector<int> tri_chart(u.indices.size(), -1);
for (size_t f = 0; f < u.indices.size(); ++f) {
const stl_triangle_vertex_indices &t = u.indices[f];
if (t[0] < 0 || size_t(t[0]) >= u.vertex_chart.size())
continue;
tri_chart[f] = u.vertex_chart[size_t(t[0])];
const auto p3 = [&](int uv_idx) -> Vec3f {
const int sv = (size_t(uv_idx) < u.source_vertex.size()) ? u.source_vertex[size_t(uv_idx)] : -1;
return (sv >= 0 && size_t(sv) < patch.vertices.size()) ? patch.vertices[size_t(sv)] : Vec3f::Zero();
};
const float a3 = 0.5f * (p3(t[1]) - p3(t[0])).cross(p3(t[2]) - p3(t[0])).norm();
const Vec2f e0 = u.uvs[size_t(t[1])] - u.uvs[size_t(t[0])];
const Vec2f e1 = u.uvs[size_t(t[2])] - u.uvs[size_t(t[0])];
const float a2 = 0.5f * std::abs(e0.x() * e1.y() - e0.y() * e1.x());
tri_log[f] = (a3 > 1e-12f && a2 > 1e-12f) ? std::log2(a2 / a3) : 0.f;
}
// Centre on the median stretch, so a globally scaled unwrap reads as uniform and only *relative*
// stretching shows up - matching the 3D overlay's convention.
std::vector<float> sorted = tri_log;
float median = 0.f;
if (!sorted.empty()) {
std::nth_element(sorted.begin(), sorted.begin() + sorted.size() / 2, sorted.end());
median = sorted[sorted.size() / 2];
}
std::vector<double> chart_sum(size_t(u.chart_count), 0.0);
std::vector<int> chart_cnt(size_t(u.chart_count), 0);
for (size_t f = 0; f < tri_log.size(); ++f) {
const int c = tri_chart[f];
if (c >= 0 && c < u.chart_count) {
chart_sum[size_t(c)] += tri_log[f];
++chart_cnt[size_t(c)];
}
}
// Blue (compressed) -> green (ideal) -> red (stretched), +/- 2 stops spanning the full range.
const auto heat = [](float t) -> ColorRGBA {
t = std::clamp(t, 0.f, 1.f);
const ColorRGBA blue{ 0.15f, 0.35f, 1.0f, 0.5f }, green{ 0.2f, 0.9f, 0.3f, 0.5f }, red{ 1.0f, 0.2f, 0.15f, 0.5f };
if (t < 0.5f) { const float s = t * 2.f; return blue * (1.f - s) + green * s; }
const float s = (t - 0.5f) * 2.f; return green * (1.f - s) + red * s;
};
m_uv_editor_distortion_colors.resize(size_t(u.chart_count), heat(0.5f));
for (int c = 0; c < u.chart_count; ++c)
if (chart_cnt[size_t(c)] > 0) {
const float avg = float(chart_sum[size_t(c)] / chart_cnt[size_t(c)]);
m_uv_editor_distortion_colors[size_t(c)] = heat(std::clamp(0.5f + (avg - median) / 4.f, 0.f, 1.f));
}
}
void GLGizmoTextureDisplacement::on_uv_command(int cmd)
{
TextureDisplacementLayer *layer = active_layer();
if (layer == nullptr)
return;
if (cmd == int(UVEditorCanvas::Command::AverageScale)) {
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Average island scale"), UndoRedo::SnapshotType::GizmoAction);
average_island_scales(layer->islands);
rebuild_preview();
} else if (cmd == int(UVEditorCanvas::Command::CutSelectedIsland)) {
UVEditorCanvas *canvas = wxGetApp().plater()->get_uv_editor_canvas();
const int chart = canvas != nullptr ? canvas->selected_island() : -1;
if (chart < 0) {
show_error(nullptr, _u8L("Select an island in the UV editor first."));
return;
}
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Cut texture island"), UndoRedo::SnapshotType::GizmoAction);
cut_island(*layer, chart);
rebuild_preview();
} else if (cmd == int(UVEditorCanvas::Command::JoinSelected)) {
UVEditorCanvas *canvas = wxGetApp().plater()->get_uv_editor_canvas();
const int chart = canvas != nullptr ? canvas->selected_island() : -1;
if (chart < 0) {
show_error(nullptr, _u8L("Select an island in the UV editor first."));
return;
}
// Join to whichever neighbouring island (one it shares an edge with) is currently placed
// nearest - i.e. the one it was dragged up against.
const Eigen::Matrix<float, 2, 3> sel_m = island_transform_matrix(chart, m_uv_editor_unwrap, layer->islands);
const Vec2f sel_c = sel_m.block<2, 2>(0, 0) * m_uv_editor_unwrap.chart_centroid[size_t(chart)] + sel_m.col(2);
int best_parent = -1;
float best_d2 = std::numeric_limits<float>::max();
TextureIsland best_place, cand;
for (int p = 0; p < m_uv_editor_unwrap.chart_count; ++p) {
if (p == chart)
continue;
if (!join_chart_placement(m_uv_editor_unwrap, layer->islands, chart, p, cand))
continue; // not a neighbour
const Eigen::Matrix<float, 2, 3> pm = island_transform_matrix(p, m_uv_editor_unwrap, layer->islands);
const Vec2f pc = pm.block<2, 2>(0, 0) * m_uv_editor_unwrap.chart_centroid[size_t(p)] + pm.col(2);
const float d2 = (pc - sel_c).squaredNorm();
if (d2 < best_d2) { best_d2 = d2; best_parent = p; best_place = cand; }
}
if (best_parent < 0) {
show_error(nullptr, _u8L("This island has no neighbour it shares an edge with."));
return;
}
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Join texture island"), UndoRedo::SnapshotType::GizmoAction);
if (layer->islands.size() <= size_t(chart))
layer->islands.resize(size_t(chart) + 1);
layer->islands[size_t(chart)] = best_place;
// Record the join so the two (and anything already grouped with either) move together from now
// on, not just visually snap once.
join_island_groups(layer->island_groups, chart, best_parent, m_uv_editor_unwrap.chart_count);
rebuild_preview();
} else if (cmd == int(UVEditorCanvas::Command::UnjoinSelected)) {
UVEditorCanvas *canvas = wxGetApp().plater()->get_uv_editor_canvas();
const int chart = canvas != nullptr ? canvas->selected_island() : -1;
if (chart < 0 || size_t(chart) >= layer->islands.size()) {
show_error(nullptr, _u8L("Select an island in the UV editor first."));
return;
}
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Unjoin texture island"), UndoRedo::SnapshotType::GizmoAction);
layer->islands[size_t(chart)] = TextureIsland{}; // back to its own packed position
// Break its join link too, so it stops moving with the others (the rest stay grouped).
if (size_t(chart) < layer->island_groups.size())
layer->island_groups[size_t(chart)] = chart;
rebuild_preview();
}
// FrameAll/ToggleSnap are handled inside the canvas; ProjectFromView is not wired yet.
}
void GLGizmoTextureDisplacement::capture_view_projection(TextureDisplacementLayer &layer)
{
const ModelVolume *mv = texture_volume();
const ModelObject *mo = m_c->selection_info()->model_object();
if (mv == nullptr || mo == nullptr)
return;
const Camera &camera = wxGetApp().plater()->get_camera();
const Selection &selection = m_parent.get_selection();
const Transform3d trafo = mo->instances[selection.get_instance_idx()]->get_transformation().get_matrix() * mv->get_matrix();
// The view matrix's rotation rows are the camera axes in world space; bring them into the
// volume's local frame (where the mesh vertices live) so the projector rides along with the part.
const Matrix3d view_rot = camera.get_view_matrix().matrix().block<3, 3>(0, 0);
const Matrix3d trafo_rot = trafo.matrix().block<3, 3>(0, 0);
const Matrix3d world_to_local = trafo_rot.inverse();
const Vec3d local_right = world_to_local * Vec3d(view_rot.row(0).transpose());
const Vec3d local_up = world_to_local * Vec3d(view_rot.row(1).transpose());
// Unit axes: the projected planar coordinate must stay in mm so tiling_scale keeps meaning mm.
layer.view_project_right = local_right.norm() > 1e-9 ? Vec3f(local_right.normalized().cast<float>()) : Vec3f::UnitX();
layer.view_project_up = local_up.norm() > 1e-9 ? Vec3f(local_up.normalized().cast<float>()) : Vec3f::UnitY();
}
void GLGizmoTextureDisplacement::show_projector(bool show)
{
if (!show) {
if (m_projector_frame != nullptr)
m_projector_frame->Hide();
return;
}
if (m_projector_frame == nullptr) {
// Parented to the main frame, not to Plater: Plater is a wxPanel, and wxFRAME_FLOAT_ON_PARENT
// wants a real top-level window to float above.
m_projector_frame = new TextureProjectorFrame(wxGetApp().mainframe);
m_projector_tex_source = nullptr; // fresh window, nothing uploaded into it yet
m_projector_tex_smoothing = -1.f;
m_projector_frame->set_opacity(m_projector_opacity);
// Opened centred over the 3D canvas, at about half its size: the frame is meant to be
// dragged onto part of the model, so starting somewhere on top of it beats the OS's default
// cascade position, which is often off over the sidebar.
if (const wxGLCanvas *cnv = m_parent.get_wxglcanvas(); cnv != nullptr) {
const wxRect area = cnv->GetScreenRect();
const wxSize size(std::max(160, area.width / 2), std::max(160, area.height / 2));
m_projector_frame->SetSize(wxRect(area.GetTopLeft() + wxPoint((area.width - size.x) / 2,
(area.height - size.y) / 2),
size));
}
}
m_projector_frame->Show();
m_projector_frame->Raise();
update_projector();
}
void GLGizmoTextureDisplacement::update_projector()
{
if (m_projector_frame == nullptr || !m_projector_frame->IsShown())
return;
const TextureDisplacementLayer *layer = active_layer();
if (layer == nullptr || layer->projection_method != TextureProjectionMethod::ViewProjected) {
m_projector_frame->set_texture({}, 0, 0);
m_projector_tex_source = nullptr;
m_projector_tex_smoothing = -1.f;
return;
}
// Only re-upload when the pixels actually changed - this is reached from the panel's per-edit
// flush, and rebuilding the bitmap from identical bytes every time would be pure waste.
if (m_projector_tex_source != layer->image_data.get() || m_projector_tex_smoothing != layer->smoothing) {
const DecodedHeightTexture height = decode_height_texture(*layer);
if (height.empty())
m_projector_frame->set_texture({}, 0, 0);
else
m_projector_frame->set_texture(height.pixels, height.width, height.height);
m_projector_tex_source = layer->image_data.get();
m_projector_tex_smoothing = layer->smoothing;
}
}
int GLGizmoTextureDisplacement::apply_projection_frame()
{
TextureDisplacementLayer *layer = active_layer();
const ModelVolume *mv = texture_volume();
const ModelObject *mo = m_c->selection_info()->model_object();
wxGLCanvas *cnv = m_parent.get_wxglcanvas();
if (layer == nullptr || mv == nullptr || mo == nullptr || cnv == nullptr || m_projector_frame == nullptr ||
!m_projector_frame->IsShown())
return -1;
// The frame's gate, brought from screen coordinates into the GL viewport's pixel space. Two
// conversions, both necessary: ScreenToClient() because the viewport's origin is the canvas's
// top-left, not the desktop's, and the retina scale because the viewport is sized in physical
// pixels (see GLCanvas3D::get_canvas_size()) while wx hands out logical ones.
const wxRect gate = m_projector_frame->client_rect_on_screen();
const wxPoint tl = cnv->ScreenToClient(gate.GetTopLeft());
const double scale = double(m_parent.get_scale());
const double rx = double(tl.x) * scale, ry = double(tl.y) * scale;
const double rw = double(gate.width) * scale, rh = double(gate.height) * scale;
if (rw < 1.0 || rh < 1.0)
return -1;
const Camera &camera = wxGetApp().plater()->get_camera();
const std::array<int, 4> &vp = camera.get_viewport();
const Selection &sel = m_parent.get_selection();
const Transform3d trafo = mo->instances[sel.get_instance_idx()]->get_transformation().get_matrix() * mv->get_matrix();
// Local space -> clip space, the same product the renderer uses, so the mapping agrees with what
// is actually on screen rather than with an idealisation of it.
const Eigen::Matrix4d K = camera.get_projection_matrix().matrix() * camera.get_view_matrix().matrix() * trafo.matrix();
// Window coordinates follow igl::project's convention (as CameraUtils::project does):
// win_x = vp.x + vp.w * (ndc.x + 1) / 2, and y measured downward as vp.h - win_y_gl.
// Turning those into uv = (win - rect_origin) / rect_size gives u and v as affine functions of
// ndc.x and ndc.y, and since ndc = clip.xyz / clip.w, multiplying through by clip.w leaves a
// plain linear combination of K's rows - i.e. one 3x4 matrix carrying the perspective divide.
const double A = double(vp[2]) / (2.0 * rw);
const double B = (double(vp[0]) + double(vp[2]) * 0.5 - rx) / rw;
const double C = -double(vp[3]) / (2.0 * rh);
const double D = (double(vp[3]) * 0.5 - double(vp[1]) - ry) / rh;
const Eigen::Vector4d row_u = A * K.row(0).transpose() + B * K.row(3).transpose();
const Eigen::Vector4d row_v = C * K.row(1).transpose() + D * K.row(3).transpose();
const Eigen::Vector4d row_w = K.row(3).transpose();
std::array<float, 12> m{};
for (int i = 0; i < 4; ++i) {
m[size_t(i)] = float(row_u[i]);
m[size_t(4 + i)] = float(row_v[i]);
m[size_t(8 + i)] = float(row_w[i]);
}
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Apply texture projection frame"),
UndoRedo::SnapshotType::GizmoAction);
layer->projection_method = TextureProjectionMethod::ViewProjected;
layer->view_project_projective = true;
layer->view_project_matrix = m;
// Off, so the height sampler returns 0 outside [0,1) and the frame's border becomes a hard edge
// of the displacement rather than the first seam of an endless repeat.
layer->tile_enabled = false;
// The affine axes are kept up to date too, so turning the projective mapping off later leaves a
// sane flat projection from this same viewpoint instead of whatever was captured long ago.
capture_view_projection(*layer);
const int painted = select_visible_faces(&m);
m_preview_params_dirty = true;
rebuild_preview();
m_parent.set_as_dirty();
return painted;
}
void GLGizmoTextureDisplacement::cut_island(TextureDisplacementLayer &layer, int chart)
{
const ModelVolume *mv = texture_volume();
if (mv == nullptr)
return;
const std::vector<Vec3f> &verts = mv->mesh().its.vertices;
const PatchUnwrap &u = m_uv_editor_unwrap;
// Collect the chart's triangles back in mesh-vertex space, and its 3D bounding box.
std::vector<std::array<int, 3>> tris;
Vec3f lo(std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max());
Vec3f hi(std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest());
for (const stl_triangle_vertex_indices &t : u.indices) {
if (t[0] < 0 || size_t(t[0]) >= u.vertex_chart.size() || u.vertex_chart[size_t(t[0])] != chart)
continue;
std::array<int, 3> bt{};
bool ok = true;
for (int k = 0; k < 3; ++k) {
const int uvv = t[k];
if (uvv < 0 || size_t(uvv) >= u.source_vertex.size()) { ok = false; break; }
const int base = u.source_vertex[size_t(uvv)];
if (base < 0 || size_t(base) >= verts.size()) { ok = false; break; }
bt[k] = base;
lo = lo.cwiseMin(verts[size_t(base)]);
hi = hi.cwiseMax(verts[size_t(base)]);
}
if (ok)
tris.push_back(bt);
}
if (tris.empty())
return;
// Cut perpendicular to the longest axis, through the centroid - a long thin island is split
// across its narrow middle, which is exactly the "islands might be very long" case.
const Vec3f ext = hi - lo;
const int axis = (ext.x() >= ext.y() && ext.x() >= ext.z()) ? 0 : (ext.y() >= ext.z() ? 1 : 2);
const float mid = 0.5f * (lo[axis] + hi[axis]);
std::set<std::pair<int, int>> seams(layer.lscm_seam_edges.begin(), layer.lscm_seam_edges.end());
for (const std::array<int, 3> &bt : tris)
for (int i = 0; i < 3; ++i) {
const int a = bt[i], b = bt[(i + 1) % 3];
// Endpoints on opposite sides of the plane -> this edge crosses it -> make it a seam.
if ((verts[size_t(a)][axis] < mid) != (verts[size_t(b)][axis] < mid))
seams.insert({ std::min(a, b), std::max(a, b) });
}
layer.lscm_seam_edges.assign(seams.begin(), seams.end());
}
// unwrap mm -> texture uv, per island: the island's own hand placement, then the layer's
// tiling/rotation/offset. Both are affine, so they compose into one matrix the canvas can hand
// straight to a shader.
std::vector<Eigen::Matrix<float, 2, 3>>
GLGizmoTextureDisplacement::uv_editor_island_transforms(const TextureDisplacementLayer &layer)
{
const float uv_scale = (layer.tiling_scale > 1e-6f) ? (1.f / layer.tiling_scale) : 1.f;
const float rad = layer.rotation_deg * float(M_PI) / 180.f;
const float cs = std::cos(rad) * uv_scale;
const float sn = std::sin(rad) * uv_scale;
Eigen::Matrix2f uv_linear;
uv_linear << cs, -sn,
sn, cs;
m_uv_editor_bbox_min = Vec2f(std::numeric_limits<float>::max(), std::numeric_limits<float>::max());
m_uv_editor_bbox_max = Vec2f(std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest());
std::vector<Eigen::Matrix<float, 2, 3>> transforms(size_t(std::max(m_uv_editor_unwrap.chart_count, 0)));
for (int c = 0; c < m_uv_editor_unwrap.chart_count; ++c) {
const Eigen::Matrix<float, 2, 3> island = island_transform_matrix(c, m_uv_editor_unwrap, layer.islands);
Eigen::Matrix<float, 2, 3> &m = transforms[size_t(c)];
m.block<2, 2>(0, 0) = uv_linear * island.block<2, 2>(0, 0);
m.col(2) = uv_linear * island.col(2) + layer.offset;
}
// Only for the panel's readout; the canvas computes its own bounds.
for (size_t i = 0; i < m_uv_editor_unwrap.uvs.size(); ++i) {
const int c = m_uv_editor_unwrap.vertex_chart[i];
if (c < 0 || size_t(c) >= transforms.size())
continue;
const Vec2f uv = transforms[size_t(c)].block<2, 2>(0, 0) * m_uv_editor_unwrap.uvs[i] + transforms[size_t(c)].col(2);
m_uv_editor_bbox_min = m_uv_editor_bbox_min.cwiseMin(uv);
m_uv_editor_bbox_max = m_uv_editor_bbox_max.cwiseMax(uv);
}
return transforms;
}
void GLGizmoTextureDisplacement::on_island_edited(int island, const Vec2f &offset_delta, float rotation_delta,
float scale_factor, bool finished)
{
TextureDisplacementLayer *layer = active_layer();
if (layer == nullptr || island < 0)
return;
if (size_t(island) >= layer->islands.size())
layer->islands.resize(size_t(island) + 1);
// A pure translation (no rotation, no scale) is the only gesture that moves a whole group/selection
// together; rotate and scale stay on the primary island alone. This split is what makes flagging a
// group's worth of vertices on the GPU safe: the shared shader delta is a pure translation, so the
// same offset is correct for every flagged island.
const bool is_move = rotation_delta == 0.f && scale_factor == 1.f;
if (!m_island_drag_active) {
// Taken before the first delta lands, so one undo reverts the whole drag rather than just
// its final mouse-move.
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Move texture island"), UndoRedo::SnapshotType::GizmoAction);
m_island_drag_active = true;
// Decide the moved set once, at drag start: the whole selection + join groups for a move, or
// just the primary for a rotate/scale.
m_island_move_set = is_move ? build_island_move_set(*layer, island) : std::vector<int>{ island };
// Set up the GPU drag: flag the moved islands' vertices and bake the mesh once (via the dirty
// flag). From then on the drag is a uniform update, no rebuild - see render_bump_preview_mesh().
m_bump_active_chart = island;
compute_bump_active_vertices(m_island_move_set);
m_bump_island_delta = Eigen::Matrix<float, 2, 3>::Identity();
m_bump_preview_dirty = true;
}
// Apply the edit. A move goes to every island in the moved set (same offset -> they translate as
// one); a rotate/scale goes only to the primary, about its own centroid.
const std::vector<int> single{ island };
const std::vector<int> &targets = (is_move && !m_island_move_set.empty()) ? m_island_move_set : single;
for (int c : targets) {
if (c < 0)
continue;
if (size_t(c) >= layer->islands.size())
layer->islands.resize(size_t(c) + 1);
TextureIsland &target = layer->islands[size_t(c)];
target.offset += offset_delta;
if (c == island) {
target.rotation_deg += rotation_delta;
// Guarded: a scale that reaches zero is unrecoverable (every subsequent factor multiplies it)
// and would collapse the island to a point - exactly the failure this feature hit once already.
target.scale = std::clamp(target.scale * scale_factor, 0.001f, 1000.f);
}
}
if (finished) {
m_island_drag_active = false;
m_bump_active_chart = -1;
m_bump_active_vertex.clear();
m_island_move_set.clear();
m_bump_island_delta = Eigen::Matrix<float, 2, 3>::Identity();
rebuild_preview(); // the real displaced geometry moved: recompute it once, at the end
} else {
const std::vector<Eigen::Matrix<float, 2, 3>> xf = uv_editor_island_transforms(*layer);
if (UVEditorCanvas *uv_canvas = wxGetApp().plater()->get_uv_editor_canvas()) {
// Live feedback in the pane, and deliberately *just* the transforms: nothing about the
// unwrap changed, so none of the vertex buffers need touching. This is what makes a drag
// interactive on a patch with a million triangles.
uv_canvas->set_island_transforms(xf);
}
// Move the island on the model live through the shader's island_delta uniform - no mesh
// rebuild. delta = F_current * F_baked^-1 in final-uv space (the bump mesh bakes F_baked; the
// shader applies delta to the flagged island's uv). The one rebuild that bakes the flags is
// scheduled at drag start above and consumed once per frame by render_painter_gizmo().
if (m_use_bump_preview && m_bump_active_chart == island && size_t(island) < xf.size()) {
Eigen::Matrix3f cur = Eigen::Matrix3f::Identity();
cur.topRows<2>() = xf[size_t(island)];
Eigen::Matrix3f bak = Eigen::Matrix3f::Identity();
bak.topRows<2>() = m_bump_baked_active_xf;
m_bump_island_delta = (cur * bak.inverse()).topRows<2>();
m_parent.set_as_dirty();
}
}
}
void GLGizmoTextureDisplacement::on_uv_vertex_edited(const std::vector<std::pair<int, Vec2f>> &edits)
{
TextureDisplacementLayer *layer = active_layer();
if (layer == nullptr || edits.empty() || m_uv_editor_unwrap.empty())
return;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Edit texture UV"), UndoRedo::SnapshotType::GizmoAction);
for (const auto &[unwrapped, raw_uv] : edits) {
if (unwrapped < 0 || size_t(unwrapped) >= m_uv_editor_unwrap.source_vertex.size())
continue;
// Keep the gizmo's own unwrap copy in step, so the pane and the bake agree without a re-solve.
if (size_t(unwrapped) < m_uv_editor_unwrap.uvs.size())
m_uv_editor_unwrap.uvs[size_t(unwrapped)] = raw_uv;
const int mesh_v = m_uv_editor_unwrap.source_vertex[size_t(unwrapped)];
if (mesh_v < 0)
continue;
// Store (or update) the override for this mesh vertex. Small list, linear scan is fine.
auto it = std::find_if(layer->lscm_uv_overrides.begin(), layer->lscm_uv_overrides.end(),
[mesh_v](const std::pair<int, Vec2f> &p) { return p.first == mesh_v; });
if (it != layer->lscm_uv_overrides.end())
it->second = raw_uv;
else
layer->lscm_uv_overrides.emplace_back(mesh_v, raw_uv);
}
rebuild_preview(); // the baked displacement samples the moved uv now
}
bool GLGizmoTextureDisplacement::update_adjust_anchor()
{
const ModelVolume *mv = texture_volume();
m_adjust_anchor_valid = mv != nullptr &&
compute_layer_paint_anchor(mv->mesh().its, mv->texture_displacement_facet(m_active_layer_slot).get_data(),
m_adjust_anchor_pos, m_adjust_anchor_normal);
return m_adjust_anchor_valid;
}
TextureDisplacementLayer *GLGizmoTextureDisplacement::active_layer()
{
ModelVolume *mv = texture_volume();
if (mv == nullptr)
return nullptr;
for (TextureDisplacementLayer &l : mv->texture_displacement_layers)
if (l.slot == m_active_layer_slot)
return &l;
return nullptr;
}
const TextureDisplacementLayer *GLGizmoTextureDisplacement::active_layer() const
{
return const_cast<GLGizmoTextureDisplacement *>(this)->active_layer();
}
Vec3f GLGizmoTextureDisplacement::adjust_plane_point() const
{
const ModelVolume *mv = texture_volume();
const float bbox_size = (mv != nullptr) ? float(mv->mesh().bounding_box().size().norm()) : 1.f;
const float lift = bbox_size * 0.01f + 0.2f; // clear of the surface, to avoid z-fighting
return m_adjust_anchor_pos + m_adjust_anchor_normal * lift;
}
Vec3f GLGizmoTextureDisplacement::adjust_handle_center(const TextureDisplacementLayer &layer) const
{
// apply_uv_transform() maps a planar mm coordinate p to uv = R(p / tiling_scale) + offset, and
// on_mouse_adjust_texture() drives offset by offset = offset_start - R(delta / tiling_scale).
// Inverting that, the handle's displacement from the anchor is - R^-1(offset) * tiling_scale -
// which, substituted into the drag equation, moves the handle by exactly `delta`. So the handle
// follows the cursor precisely, and is back on the anchor exactly when offset is zero.
const float rad = layer.rotation_deg * float(M_PI) / 180.f;
const float cs = std::cos(rad), sn = std::sin(rad);
const Vec2f unrotated(layer.offset.x() * cs + layer.offset.y() * sn, -layer.offset.x() * sn + layer.offset.y() * cs);
const Vec2f planar = -unrotated * layer.tiling_scale;
Vec3f u_axis, v_axis;
adjust_tangent_basis(u_axis, v_axis);
return adjust_plane_point() + u_axis * planar.x() + v_axis * planar.y();
}
void GLGizmoTextureDisplacement::adjust_tangent_basis(Vec3f &u_axis, Vec3f &v_axis) const
{
// Mirrors project_planar()'s own dominant-axis choice exactly, so the ring's "0 degrees" and
// the offset handle's plane always agree with what project_texture_displacement_uv() does.
const Vec3f n = m_adjust_anchor_normal.cwiseAbs();
if (n.x() >= n.y() && n.x() >= n.z()) {
u_axis = Vec3f::UnitY();
v_axis = Vec3f::UnitZ();
} else if (n.y() >= n.x() && n.y() >= n.z()) {
u_axis = Vec3f::UnitX();
v_axis = Vec3f::UnitZ();
} else {
u_axis = Vec3f::UnitX();
v_axis = Vec3f::UnitY();
}
}
void GLGizmoTextureDisplacement::render_adjust_texture_gizmo()
{
if (!m_adjust_anchor_valid)
return;
const ModelObject *mo = m_c->selection_info()->model_object();
const ModelVolume *mv = texture_volume();
const TextureDisplacementLayer *layer = active_layer();
if (mo == nullptr || mv == nullptr || layer == nullptr)
return;
const Selection &selection = m_parent.get_selection();
const Transform3d trafo_matrix = mo->instances[selection.get_instance_idx()]->get_transformation().get_matrix() * mv->get_matrix();
// Handle sizes scale with the volume so they stay usable on both tiny and huge models.
const float bbox_size = float(mv->mesh().bounding_box().size().norm());
const float panel_half = bbox_size * 0.04f + 1.f;
const float arrow_length = panel_half * 2.2f;
// Tracks the layer's offset, so the handle actually travels with the texture as it is dragged.
const Vec3f handle_center_local = adjust_handle_center(*layer);
GLShaderProgram *shader = wxGetApp().get_shader("flat");
if (shader == nullptr)
return;
glsafe(::glDisable(GL_DEPTH_TEST));
glsafe(::glEnable(GL_BLEND));
shader->start_using();
const Camera &camera = wxGetApp().plater()->get_camera();
Vec3f u_axis, v_axis;
adjust_tangent_basis(u_axis, v_axis);
Transform3d plane_transform = Transform3d::Identity();
plane_transform.linear().col(0) = u_axis.cast<double>();
plane_transform.linear().col(1) = v_axis.cast<double>();
plane_transform.linear().col(2) = m_adjust_anchor_normal.cast<double>();
plane_transform.translation() = handle_center_local.cast<double>();
// Pan panel: a flat square lying in the patch's own tangent plane. Dragging anywhere on it
// moves the texture freely along both axes at once.
if (!m_adjust_panel_glmodel.is_initialized()) {
GLModel::Geometry init_data;
init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3 };
init_data.reserve_vertices(4);
init_data.reserve_indices(6);
init_data.add_vertex(Vec3f(-1.f, -1.f, 0.f));
init_data.add_vertex(Vec3f(1.f, -1.f, 0.f));
init_data.add_vertex(Vec3f(1.f, 1.f, 0.f));
init_data.add_vertex(Vec3f(-1.f, 1.f, 0.f));
init_data.add_triangle(0, 1, 2);
init_data.add_triangle(0, 2, 3);
m_adjust_panel_glmodel.init_from(std::move(init_data));
}
Transform3d view_model_matrix = camera.get_view_matrix() * trafo_matrix * plane_transform *
Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), Vec3d(panel_half, panel_half, panel_half));
shader->set_uniform("view_model_matrix", view_model_matrix);
shader->set_uniform("projection_matrix", camera.get_projection_matrix());
ColorRGBA panel_color = m_adjust_drag_handle == AdjustHandle::Pan ? ColorRGBA::YELLOW() : ColorRGBA::ORANGE();
panel_color.a(0.45f);
m_adjust_panel_glmodel.set_color(panel_color);
m_adjust_panel_glmodel.render();
// Axis arrows: a shaft plus a small V-shaped arrowhead, both along local +X. Reused for both
// the U and V axes below by swapping which world direction local +X is transformed to.
if (!m_adjust_arrow_glmodel.is_initialized()) {
GLModel::Geometry init_data;
init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
init_data.reserve_vertices(4);
init_data.reserve_indices(6);
init_data.add_vertex(Vec3f(0.f, 0.f, 0.f));
init_data.add_vertex(Vec3f(1.f, 0.f, 0.f));
init_data.add_vertex(Vec3f(0.82f, 0.08f, 0.f));
init_data.add_vertex(Vec3f(0.82f, -0.08f, 0.f));
init_data.add_line(0, 1);
init_data.add_line(1, 2);
init_data.add_line(1, 3);
m_adjust_arrow_glmodel.init_from(std::move(init_data));
}
#if !SLIC3R_OPENGL_ES
if (!OpenGLManager::get_gl_info().is_core_profile())
glsafe(::glLineWidth(2.0f));
#endif // !SLIC3R_OPENGL_ES
auto render_arrow = [&](const Vec3f &axis, const Vec3f &other_axis, bool is_active) {
Transform3d arrow_transform = Transform3d::Identity();
arrow_transform.linear().col(0) = axis.cast<double>();
arrow_transform.linear().col(1) = other_axis.cast<double>();
arrow_transform.linear().col(2) = m_adjust_anchor_normal.cast<double>();
arrow_transform.translation() = handle_center_local.cast<double>();
const Transform3d vmm = camera.get_view_matrix() * trafo_matrix * arrow_transform *
Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), Vec3d(arrow_length, arrow_length, arrow_length));
shader->set_uniform("view_model_matrix", vmm);
shader->set_uniform("projection_matrix", camera.get_projection_matrix());
m_adjust_arrow_glmodel.set_color(is_active ? ColorRGBA::YELLOW() : ColorRGBA::ORANGE());
m_adjust_arrow_glmodel.render();
};
render_arrow(u_axis, v_axis, m_adjust_drag_handle == AdjustHandle::AxisU);
render_arrow(v_axis, u_axis, m_adjust_drag_handle == AdjustHandle::AxisV);
shader->stop_using();
glsafe(::glDisable(GL_BLEND));
glsafe(::glEnable(GL_DEPTH_TEST));
}
bool GLGizmoTextureDisplacement::on_mouse_adjust_texture(const wxMouseEvent &mouse_event)
{
if (!m_adjust_anchor_valid)
return false;
ModelVolume *mv = texture_volume();
ModelObject *mo = m_c->selection_info()->model_object();
TextureDisplacementLayer *layer = active_layer();
if (mv == nullptr || mo == nullptr || layer == nullptr)
return false;
const Selection &selection = m_parent.get_selection();
const Transform3d trafo_matrix = mo->instances[selection.get_instance_idx()]->get_transformation().get_matrix() * mv->get_matrix();
const Camera &camera = wxGetApp().plater()->get_camera();
const float bbox_size = float(mv->mesh().bounding_box().size().norm());
const float panel_half = bbox_size * 0.04f + 1.f;
const float arrow_length = panel_half * 2.2f;
// Where the handle is drawn (moves with the layer's offset) vs. the plane the drag is measured
// against (fixed at the anchor). Keeping them apart is what stops the handle's own motion from
// feeding back into the delta that produced it.
const Vec3f handle_center_local = adjust_handle_center(*layer);
const Vec3f drag_plane_local = adjust_plane_point();
const Vec3d handle_center_world = trafo_matrix * handle_center_local.cast<double>();
const Vec2d mouse_pos(mouse_event.GetX(), mouse_event.GetY());
Vec3f u_axis, v_axis;
adjust_tangent_basis(u_axis, v_axis);
const Point handle_screen = CameraUtils::project(camera, handle_center_world);
const Vec2d handle_screen_d(double(handle_screen.x()), double(handle_screen.y()));
// Point-to-segment distance in screen space, for the arrow shafts.
auto dist_to_segment_px = [](const Vec2d &p, const Vec2d &a, const Vec2d &b) {
const Vec2d ab = b - a;
const double len2 = ab.squaredNorm();
const double t = (len2 > 1e-9) ? std::clamp((p - a).dot(ab) / len2, 0.0, 1.0) : 0.0;
return (p - (a + ab * t)).norm();
};
if (mouse_event.LeftDown()) {
const Vec3d u_tip_world = trafo_matrix * (handle_center_local + u_axis * arrow_length).cast<double>();
const Vec3d v_tip_world = trafo_matrix * (handle_center_local + v_axis * arrow_length).cast<double>();
const Point u_tip_screen = CameraUtils::project(camera, u_tip_world);
const Point v_tip_screen = CameraUtils::project(camera, v_tip_world);
const Vec2d u_tip_screen_d(double(u_tip_screen.x()), double(u_tip_screen.y()));
const Vec2d v_tip_screen_d(double(v_tip_screen.x()), double(v_tip_screen.y()));
// Panel screen-space "radius", approximated from one corner (a loose circle around the
// square is close enough for hit-testing purposes).
const Vec3d panel_corner_world = trafo_matrix * (handle_center_local + (u_axis + v_axis) * panel_half).cast<double>();
const Point panel_corner_screen = CameraUtils::project(camera, panel_corner_world);
const double panel_screen_radius = (Vec2d(double(panel_corner_screen.x()), double(panel_corner_screen.y())) - handle_screen_d).norm();
constexpr double pick_tolerance_px = 8.0;
const double dist_to_u = dist_to_segment_px(mouse_pos, handle_screen_d, u_tip_screen_d);
const double dist_to_v = dist_to_segment_px(mouse_pos, handle_screen_d, v_tip_screen_d);
const double dist_to_panel = (handle_screen_d - mouse_pos).norm();
// Arrows take priority over the panel (their tips extend past it), then the panel covers
// the broader central area.
if (dist_to_u <= pick_tolerance_px && dist_to_u <= dist_to_v)
m_adjust_drag_handle = AdjustHandle::AxisU;
else if (dist_to_v <= pick_tolerance_px)
m_adjust_drag_handle = AdjustHandle::AxisV;
else if (dist_to_panel <= panel_screen_radius)
m_adjust_drag_handle = AdjustHandle::Pan;
else {
m_adjust_drag_handle = AdjustHandle::None;
return false;
}
m_adjust_drag_start_offset = layer->offset;
Vec3d world_hit;
if (ray_plane_hit(camera, mouse_pos, trafo_matrix, drag_plane_local, m_adjust_anchor_normal, world_hit)) {
const Vec3f local_hit = (trafo_matrix.inverse() * world_hit).cast<float>();
m_adjust_drag_start_planar = project_planar(local_hit, m_adjust_anchor_normal);
}
return true;
}
if (mouse_event.Dragging() && m_adjust_drag_handle != AdjustHandle::None) {
Vec3d world_hit;
if (!ray_plane_hit(camera, mouse_pos, trafo_matrix, drag_plane_local, m_adjust_anchor_normal, world_hit))
return true;
const Vec3f local_hit = (trafo_matrix.inverse() * world_hit).cast<float>();
const Vec2f current_planar = project_planar(local_hit, m_adjust_anchor_normal);
Vec2f delta_planar = current_planar - m_adjust_drag_start_planar;
// project_planar()'s (x, y) axes are exactly u_axis/v_axis (see adjust_tangent_basis()),
// so zeroing one component constrains the drag to only the other axis.
if (m_adjust_drag_handle == AdjustHandle::AxisU)
delta_planar.y() = 0.f;
else if (m_adjust_drag_handle == AdjustHandle::AxisV)
delta_planar.x() = 0.f;
const float scale = (layer->tiling_scale > 1e-6f) ? (1.f / layer->tiling_scale) : 1.f;
const Vec2f delta_scaled = delta_planar * scale;
const float rad = layer->rotation_deg * float(M_PI) / 180.f;
const float cs = std::cos(rad), sn = std::sin(rad);
const Vec2f delta_rotated(delta_scaled.x() * cs - delta_scaled.y() * sn, delta_scaled.x() * sn + delta_scaled.y() * cs);
// Increasing `offset` shifts which texel is sampled at a fixed world position, which
// visually slides the pattern the *opposite* way - subtracting is this session's
// best-effort reasoning about the direction that feels like "dragging the texture",
// unverified against an actual render (see header comment).
layer->offset = m_adjust_drag_start_offset - delta_rotated;
m_preview_params_dirty = true;
m_parent.set_as_dirty();
return true;
}
if (mouse_event.LeftUp() && m_adjust_drag_handle != AdjustHandle::None) {
m_adjust_drag_handle = AdjustHandle::None;
rebuild_preview();
m_preview_params_dirty = false;
return true;
}
return false;
}
ModelVolume* GLGizmoTextureDisplacement::texture_volume()
{
ModelObject *mo = m_c->selection_info()->model_object();
if (!mo)
return nullptr;
for (ModelVolume *mv : mo->volumes)
if (mv->is_model_part())
return mv;
return nullptr;
}
const ModelVolume* GLGizmoTextureDisplacement::texture_volume() const
{
return const_cast<GLGizmoTextureDisplacement *>(this)->texture_volume();
}
void GLGizmoTextureDisplacement::update_model_object()
{
bool updated = false;
ModelObject *mo = m_c->selection_info()->model_object();
int idx = -1;
for (ModelVolume *mv : mo->volumes) {
if (!mv->is_model_part())
continue;
++idx;
updated |= mv->texture_displacement_facet(m_active_layer_slot).set(*m_triangle_selectors[idx]);
}
// The fast (bump) preview reads the live selector, so it has to be rebuilt after any stroke that
// flushes here - not only when set() reports a change. Rebuilding it via rebuild_preview() below
// is gated on `updated`, which misses e.g. the first paint into a slot; marking it dirty makes the
// render loop (render_painter_gizmo) rebuild it next frame regardless. Without this, fast preview -
// now the default view - stayed blank until a full reload (select-whole-model / reopen).
m_bump_preview_dirty = true;
if (updated) {
const ModelObjectPtrs &mos = wxGetApp().model().objects;
wxGetApp().obj_list()->update_info_items(std::find(mos.begin(), mos.end(), mo) - mos.begin());
m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
rebuild_preview();
}
}
void GLGizmoTextureDisplacement::update_from_model_object(bool first_update)
{
wxBusyCursor wait;
const ModelObject *mo = m_c->selection_info()->model_object();
m_triangle_selectors.clear();
std::vector<ColorRGBA> ebt_colors;
ebt_colors.push_back(GLVolume::NEUTRAL_COLOR);
ebt_colors.push_back(TriangleSelectorGUI::enforcers_color);
ebt_colors.push_back(TriangleSelectorGUI::blockers_color);
for (const ModelVolume *mv : mo->volumes) {
if (!mv->is_model_part())
continue;
const TriangleMesh *mesh = &mv->mesh();
m_triangle_selectors.emplace_back(std::make_unique<TriangleSelectorPatch>(*mesh, ebt_colors));
m_triangle_selectors.back()->deserialize(mv->texture_displacement_facet(m_active_layer_slot).get_data(), false);
m_triangle_selectors.back()->request_update_render_data();
}
// Start a freshly opened, never-textured volume with one layer already in place, so the panel is
// ready to paint straight away rather than showing an empty layer list. Only on first open, and
// only when there are none - never during an undo/redo or layer-switch reload (which also come
// through here), where silently adding a layer would be wrong.
if (first_update)
if (ModelVolume *tv = texture_volume(); tv != nullptr && tv->texture_displacement_layers.empty()) {
add_texture_layer(); // takes its own snapshot and rebuilds the preview
return;
}
rebuild_preview();
}
void GLGizmoTextureDisplacement::set_active_layer(int slot)
{
if (slot == m_active_layer_slot)
return;
// Flush edits made while the previous layer was active before switching what the selectors
// reflect - otherwise they would be silently lost.
update_model_object();
m_active_layer_slot = slot;
update_from_model_object(false);
// The on-canvas gizmo (if on) is anchored to whichever layer is active - keep it in sync
// instead of leaving it pointing at the previous layer's (now stale) paint patch.
if (m_adjust_texture_mode)
update_adjust_anchor();
// Refresh every preview/overlay (bump, UV editor, seams, ...) for the newly active layer.
rebuild_preview();
}
unsigned int GLGizmoTextureDisplacement::tool_icon_id()
{
if (!m_tool_icon_tried) {
m_tool_icon_tried = true;
// Runs from the panel render, i.e. with a GL context current, so the upload is safe here.
m_tool_icon.load_from_svg_file(resources_dir() + "/images/texture_displacement_add.svg", false, false, false, 32);
}
return m_tool_icon.get_id();
}
void GLGizmoTextureDisplacement::ensure_panel_icons()
{
if (m_panel_icons_tried)
return;
m_panel_icons_tried = true;
// Order is irrelevant; the map keys by file name. Loaded with color_wite_gray so each icon has both
// a monochrome ("normal", grey in the current theme) and an original-colour variant.
static const std::vector<std::string> names = {
"toolbar_big_brush.svg", "toolbar_face.svg", "texture_displacement_connected_area.svg",
"texture_displacement_real_preview.svg", "texture_displacement_fast_preview.svg",
"texture_displacement_checker.svg", "texture_displacement_distortion.svg",
"texture_displacement_wireframe.svg", "texture_displacement_cross.svg",
"texture_displacement_uv_select_island.svg", "texture_displacement_uv_select_edge.svg",
"texture_displacement_uv_select_vertex.svg",
};
std::vector<std::string> paths;
paths.reserve(names.size());
for (const std::string &n : names)
paths.push_back(resources_dir() + "/images/" + n);
// Runs from the panel render, i.e. with a GL context current, so the upload is safe here.
//
// Rasterized at twice GLToolbar::Default_Icons_Size rather than at it: these are drawn at the
// toolbar's icon size, which is that constant scaled by DPI (toolbar_icon_scale() folds in
// em_unit), so on a 200% display the draw size reaches 80 px. Rasterizing at 40 would upscale a
// 40 px bitmap there, which is what actually reads as blurry - downscaling does not. The icon set
// is rasterized once for the gizmo's lifetime, so it cannot re-raster on a DPI change; sizing for
// the larger case and letting ImGui shrink it is the version that looks right on both.
const std::vector<IconManager::Icons> icons =
m_panel_icons.init(paths, ImVec2(2 * GLToolbar::Default_Icons_Size, 2 * GLToolbar::Default_Icons_Size),
IconManager::RasterType::color_wite_gray);
for (size_t i = 0; i < names.size() && i < icons.size(); ++i)
m_panel_icon_map[names[i]] = icons[i];
}
void GLGizmoTextureDisplacement::add_texture_layer()
{
ModelVolume *mv = texture_volume();
if (!mv)
return;
std::array<bool, TEXTURE_DISPLACEMENT_MAX_LAYERS> used{};
for (const TextureDisplacementLayer &l : mv->texture_displacement_layers)
if (l.slot >= 0 && size_t(l.slot) < used.size())
used[size_t(l.slot)] = true;
int free_slot = -1;
for (size_t i = 0; i < used.size(); ++i)
if (!used[i]) { free_slot = int(i); break; }
if (free_slot < 0) {
show_error(nullptr, _u8L("Maximum number of texture displacement layers reached."));
return;
}
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Add texture displacement layer"), UndoRedo::SnapshotType::GizmoAction);
TextureDisplacementLayer layer;
layer.slot = free_slot;
// Start the layer off on the first library texture rather than on nothing at all: a textureless
// layer looks broken (painting on it appears to do nothing, because there is no height map to
// displace by). The user swaps it for another from the layer's own picker.
const std::vector<TextureLibraryEntry> &library = texture_library();
if (!library.empty())
if (const LibraryTexture *tex = get_library_texture(library.front().path)) {
layer.name = library.front().name;
layer.path = library.front().path;
layer.image_data = tex->image_data;
}
mv->texture_displacement_layers.push_back(std::move(layer));
set_active_layer(free_slot);
// set_active_layer() is a no-op when the new slot happens to be the one already active (slot 0,
// for the very first layer added), so the preview would not pick the new texture up on its own.
rebuild_preview();
m_parent.set_as_dirty();
}
const GLGizmoTextureDisplacement::LibraryTexture *GLGizmoTextureDisplacement::get_library_texture(const std::string &path)
{
if (auto it = m_library_textures.find(path); it != m_library_textures.end())
return it->second.image_data ? &it->second : nullptr;
LibraryTexture entry;
std::string error;
entry.image_data = load_texture_image_data(path, error);
if (entry.image_data) {
TextureDisplacementLayer probe;
probe.image_data = entry.image_data;
entry.thumbnail = upload_height_thumbnail(decode_height_texture(probe));
if (!entry.thumbnail)
entry.image_data.reset(); // decoded to nothing usable - treat it as a failed load
} else {
BOOST_LOG_TRIVIAL(error) << "Texture displacement: could not load texture " << path << ": " << error;
}
// Cached whether it loaded or not: a file that failed is remembered as unusable, so the picker
// does not retry (and re-log) it on every frame it is on screen.
const auto [pos, inserted] = m_library_textures.emplace(path, std::move(entry));
return pos->second.image_data ? &pos->second : nullptr;
}
void GLGizmoTextureDisplacement::set_layer_texture(TextureDisplacementLayer &layer, const TextureLibraryEntry &entry)
{
const LibraryTexture *tex = get_library_texture(entry.path);
if (tex == nullptr) {
show_error(nullptr, _u8L("Could not load the selected texture."));
return;
}
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Change texture displacement texture"), UndoRedo::SnapshotType::GizmoAction);
layer.name = entry.name;
layer.path = entry.path;
// Handing over the library's own buffer (rather than a copy) is what lets decode_height_texture()
// - whose cache is keyed by exactly this pointer - hit straight away instead of re-decoding
// the PNG the first time the layer is previewed or baked.
layer.image_data = tex->image_data;
rebuild_preview();
m_parent.set_as_dirty();
}
void GLGizmoTextureDisplacement::import_custom_texture(TextureDisplacementLayer &layer)
{
const wxString wildcard = "Images (*.png;*.jpg;*.jpeg;*.bmp)|*.png;*.jpg;*.jpeg;*.bmp";
wxFileDialog dialog(nullptr, _L("Choose a texture image (height map)"), wxEmptyString, wxEmptyString, wildcard,
wxFD_OPEN | wxFD_FILE_MUST_EXIST);
if (dialog.ShowModal() != wxID_OK)
return;
// Converts to the 8-bit grayscale PNG the bake code understands and copies it into the user's
// own texture folder, so it stays available for later models (and survives an app update, which
// rewrites the shipped folder wholesale).
std::string error;
const std::optional<TextureLibraryEntry> entry = import_texture_to_library(into_u8(dialog.GetPath()), error);
if (!entry) {
show_error(nullptr, error);
return;
}
set_layer_texture(layer, *entry);
}
float GLGizmoTextureDisplacement::texture_row_height() const
{
return m_imgui->scaled(3.f);
}
bool GLGizmoTextureDisplacement::texture_row(const char *id, const std::string &name, GLTexture *thumbnail, bool selected, float width)
{
const float row_h = texture_row_height();
const ImVec2 start = ImGui::GetCursorPos();
const bool clicked = ImGui::Selectable(id, selected, 0, ImVec2(width, row_h));
const ImVec2 after = ImGui::GetCursorPos();
// Lay the image and the name back over the Selectable that was just emitted, so the whole row
// - preview included - is the clickable target rather than just a strip of text next to it.
ImGui::SetCursorPos(ImVec2(start.x + ImGui::GetStyle().FramePadding.x, start.y));
if (thumbnail != nullptr) {
// Fit inside a row_h square without distorting a non-square source image.
const float aspect = (thumbnail->get_height() > 0) ? float(thumbnail->get_width()) / float(thumbnail->get_height()) : 1.f;
const ImVec2 dim = (aspect >= 1.f) ? ImVec2(row_h, row_h / aspect) : ImVec2(row_h * aspect, row_h);
ImGui::Image((ImTextureID) (intptr_t) thumbnail->get_id(), dim);
ImGui::SameLine();
}
ImGui::SetCursorPosY(start.y + (row_h - ImGui::GetTextLineHeight()) * 0.5f); // centre the name on the image
ImGui::TextUnformatted(name.c_str());
ImGui::SetCursorPos(after);
return clicked;
}
void GLGizmoTextureDisplacement::render_texture_picker(TextureDisplacementLayer &layer)
{
const float row_h = texture_row_height();
const float import_btn_w = m_imgui->scaled(1.6f);
const float spacing = ImGui::GetStyle().ItemSpacing.x;
const float picker_w = std::max(m_imgui->scaled(10.f), ImGui::GetContentRegionAvail().x - import_btn_w - spacing);
const ImVec2 start = ImGui::GetCursorPos();
if (texture_row("##texture_picker", layer.name.empty() ? _u8L("Choose a texture...") : layer.name,
get_layer_thumbnail(layer), false, picker_w))
ImGui::OpenPopup("##texture_library");
const ImVec2 after = ImGui::GetCursorPos();
// Positioned explicitly rather than with SameLine(): texture_row() draws several widgets and
// then rewinds the cursor, so ImGui's notion of "the previous line" is not the row's own.
ImGui::SetCursorPos(ImVec2(start.x + picker_w + spacing, start.y));
if (ImGui::Button("+", ImVec2(import_btn_w, row_h)))
import_custom_texture(layer);
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Import your own image as a height map. It is converted to the format the slicer "
"bakes from and saved to your personal texture folder, kept separate from the "
"textures shipped with OrcaSlicer."),
m_imgui->scaled(20.f));
ImGui::SetCursorPos(after);
if (ImGui::BeginPopup("##texture_library")) {
const std::vector<TextureLibraryEntry> &library = texture_library();
if (library.empty())
m_imgui->text(_L("No textures found."));
bool shipped_heading = false;
bool user_heading = false;
for (const TextureLibraryEntry &entry : library) {
if (!entry.is_user && !shipped_heading) {
ImGui::TextDisabled("%s", _u8L("Built-in").c_str());
shipped_heading = true;
} else if (entry.is_user && !user_heading) {
if (shipped_heading)
ImGui::Separator();
ImGui::TextDisabled("%s", _u8L("My textures").c_str());
user_heading = true;
}
ImGui::PushID(entry.path.c_str());
const LibraryTexture *tex = get_library_texture(entry.path);
if (texture_row("##entry", entry.name, tex != nullptr ? tex->thumbnail.get() : nullptr,
entry.path == layer.path, m_imgui->scaled(14.f))) {
set_layer_texture(layer, entry);
ImGui::CloseCurrentPopup();
}
ImGui::PopID();
}
ImGui::EndPopup();
}
}
void GLGizmoTextureDisplacement::remove_texture_layer(int slot)
{
ModelVolume *mv = texture_volume();
if (!mv)
return;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Remove texture displacement layer"), UndoRedo::SnapshotType::GizmoAction);
auto &layers = mv->texture_displacement_layers;
layers.erase(std::remove_if(layers.begin(), layers.end(),
[slot](const TextureDisplacementLayer &l) { return l.slot == slot; }),
layers.end());
if (slot >= 0 && slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS)) {
mv->texture_displacement_facet(slot).reset();
m_thumbnails[size_t(slot)].reset();
m_thumbnail_source[size_t(slot)] = nullptr;
}
if (m_active_layer_slot == slot)
update_from_model_object(false); // also rebuilds the preview
else
rebuild_preview(); // a non-active layer's contribution to the combined preview changed
m_parent.set_as_dirty();
}
int GLGizmoTextureDisplacement::select_visible_faces(const std::array<float, 12> *uv_clip)
{
ModelVolume *mv = texture_volume();
ModelObject *mo = m_c->selection_info()->model_object();
const int idx = texture_volume_raycaster_index();
if (mv == nullptr || mo == nullptr || idx < 0 || idx >= int(m_triangle_selectors.size()))
return 0;
const indexed_triangle_set &its = mv->mesh().its;
if (its.indices.empty())
return 0;
const Selection &selection = m_parent.get_selection();
const Geometry::Transformation trafo(mo->instances[selection.get_instance_idx()]->get_transformation().get_matrix() *
mv->get_matrix());
const Transform3d &to_world = trafo.get_matrix();
const Camera &camera = wxGetApp().plater()->get_camera();
// Normals transform by the inverse transpose, not by the matrix itself - with a non-uniform
// scale the two differ, and using the wrong one flips the facing test on the scaled axes.
const Matrix3d normal_matrix = to_world.matrix().block<3, 3>(0, 0).inverse().transpose();
// Pass 1 (cheap): drop back-facing triangles. Under perspective the view direction varies across
// the model, so it is taken per triangle from the eye to the centroid; under an orthographic
// camera get_position() is still a point on the view axis, so the same expression stays correct
// in direction terms for everything actually on screen.
const Vec3d eye = camera.get_position();
const bool ortho = camera.get_type() == Camera::EType::Ortho;
const Vec3d fwd = camera.get_dir_forward();
std::vector<Vec3f> centroids; // world coords, what get_unobscured_idxs() expects
std::vector<unsigned> front_facing; // parallel: which facet each centroid came from
centroids.reserve(its.indices.size() / 2);
front_facing.reserve(its.indices.size() / 2);
for (size_t f = 0; f < its.indices.size(); ++f) {
const stl_triangle_vertex_indices &tri = its.indices[f];
const Vec3d a = its.vertices[tri[0]].cast<double>();
const Vec3d b = its.vertices[tri[1]].cast<double>();
const Vec3d c = its.vertices[tri[2]].cast<double>();
const Vec3d n_world = normal_matrix * (b - a).cross(c - a);
if (n_world.squaredNorm() < 1e-20)
continue; // degenerate triangle: no meaningful normal, so no meaningful facing test
const Vec3d centroid_local = (a + b + c) / 3.0;
const Vec3d centroid_world = to_world * centroid_local;
const Vec3d view_dir = ortho ? fwd : Vec3d(centroid_world - eye);
if (n_world.dot(view_dir) >= 0.0)
continue; // facing away from the camera
// Clip to the projection frame before the raycast, not after: outside the frame the texture
// samples to nothing anyway, so those facets would only be painted to no effect - and this
// is also what keeps the ray queries proportional to the framed area instead of the model.
if (uv_clip != nullptr) {
Vec2f uv;
if (!project_uv_projective(*uv_clip, centroid_local.cast<float>(), uv))
continue; // behind the projector
if (uv.x() < 0.f || uv.x() > 1.f || uv.y() < 0.f || uv.y() > 1.f)
continue;
}
centroids.emplace_back(centroid_world.cast<float>());
front_facing.push_back(unsigned(f));
}
if (centroids.empty())
return 0;
// Pass 2 (the expensive one): a real ray query per surviving centroid, so geometry in front of a
// front-facing triangle correctly hides it - the far inner wall of a cup is front-facing but not
// visible. This is why the whole thing is click-driven rather than live.
std::vector<unsigned> unobscured;
{
wxBusyCursor wait;
unobscured = m_c->raycaster()->raycasters()[size_t(idx)]->get_unobscured_idxs(
trafo, camera, centroids, m_c->object_clipper()->get_clipping_plane());
}
if (unobscured.empty())
return 0;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Select visible faces for texture displacement"),
UndoRedo::SnapshotType::GizmoAction);
// Replaces the layer's paint rather than adding to it: the checkbox means "project onto what I
// can see", so a second capture from a new angle should not leave the previous angle painted.
// TriangleSelectorGUI, not the TriangleSelector base: request_update_render_data() is declared on
// the GUI subclass, so binding to the base here would drop it.
TriangleSelectorGUI &selector = *m_triangle_selectors[size_t(idx)];
selector.reset();
for (unsigned i : unobscured)
selector.set_facet(int(front_facing[i]), EnforcerBlockerType::ENFORCER);
selector.request_update_render_data();
update_model_object();
m_parent.set_as_dirty();
return int(unobscured.size());
}
void GLGizmoTextureDisplacement::select_whole_model()
{
ModelObject *mo = m_c->selection_info()->model_object();
if (!mo)
return;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Select whole model for texture displacement"), UndoRedo::SnapshotType::GizmoAction);
int idx = -1;
for (const ModelVolume *v : mo->volumes) {
if (!v->is_model_part())
continue;
++idx;
const size_t facet_count = v->mesh().its.indices.size();
for (size_t i = 0; i < facet_count; ++i)
m_triangle_selectors[idx]->set_facet(int(i), EnforcerBlockerType::ENFORCER);
m_triangle_selectors[idx]->request_update_render_data();
}
update_model_object();
m_parent.set_as_dirty();
}
void GLGizmoTextureDisplacement::subdivide_model()
{
ModelVolume *mv = texture_volume();
ModelObject *mo = m_c->selection_info()->model_object();
if (mv == nullptr || mo == nullptr || m_subdivide_count < 1)
return; // 0 passes means "no subdivision" - don't take a snapshot for a no-op
Plater *plater = wxGetApp().plater();
Plater::TakeSnapshot snapshot(plater, _u8L("Subdivide model for texture displacement"), UndoRedo::SnapshotType::GizmoAction);
// Same save/replace/restore-painting dance GLGizmoSimplify uses when it re-tessellates a
// volume's mesh: supported/seam/mmu/fuzzy-skin masks get remapped onto the new triangles,
// texture-displacement doesn't (no remap support for it yet) and is dropped instead of being
// left referring to triangle indices that no longer mean the same thing.
std::optional<TriangleSelector::SavedPainting> saved_painting = mv->save_painting();
// max_edge_length 0 means "no triangle is ever small enough", so every non-degenerate edge is
// split on each of the m_subdivide_count passes - i.e. a plain "subdivide the whole mesh N times".
TriangleMesh new_mesh(subdivide_mesh_uniform(mv->mesh().its, 0.f, m_subdivide_count));
mv->set_mesh(std::move(new_mesh));
mv->set_new_unique_id();
mv->calculate_convex_hull();
mv->restore_painting(saved_painting);
if (ObjectList *obj_list = wxGetApp().obj_list()) {
const ModelObjectPtrs &objs = plater->model().objects;
auto it = std::find(objs.begin(), objs.end(), mo);
if (it != objs.end())
obj_list->update_info_items(size_t(it - objs.begin()));
}
plater->changed_object(*mo);
update_from_model_object(false); // reload selectors/preview against the new mesh + cleared paint
m_parent.set_as_dirty();
}
bool GLGizmoTextureDisplacement::collect_paint_region(
std::vector<uint8_t> &region,
std::array<std::vector<uint8_t>, TEXTURE_DISPLACEMENT_MAX_LAYERS> *painted_tri) const
{
const ModelVolume *mv = texture_volume();
if (mv == nullptr)
return false;
const indexed_triangle_set &its = mv->mesh().its;
const size_t ntri = its.indices.size();
const size_t nvert = its.vertices.size();
region.assign(ntri, 0);
if (painted_tri)
for (auto &pt : *painted_tri)
pt.clear();
// Sorted-vertex-triple -> triangle index, so a fully-painted patch sub-triangle (which comes back
// with the original mesh's own three vertex indices) can be mapped to its source triangle. Only
// the paint carry-forward needs it, and the live subdivide preview calls this on every slider
// frame, so it is not built for the region-only path.
std::map<std::array<int, 3>, int> tri_by_verts;
if (painted_tri)
for (size_t i = 0; i < ntri; ++i) {
std::array<int, 3> k{ its.indices[i][0], its.indices[i][1], its.indices[i][2] };
std::sort(k.begin(), k.end());
tri_by_verts.emplace(k, int(i));
}
bool any_paint = false;
for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot) {
const TriangleSelector::TriangleSplittingData &data = mv->texture_displacement_facet(slot).get_data();
if (!TriangleSelector::has_facets(data, EnforcerBlockerType::ENFORCER))
continue;
// The refine region is exactly the original triangles the brush touched. `triangles_to_split`
// lists precisely those: serialize() records an entry for every original triangle that is
// either split (i.e. partially painted, which is the patch boundary) or carries a non-default
// state (fully painted). No dilation - an earlier version marked every triangle sharing a
// *vertex* with the patch, which on a coarse model pulls in a whole fan of huge unpainted
// neighbours and then refines them to the resolution floor, since the height field the detail
// test samples is not restricted to the painted area. The conformal closure inside
// subdivide_mesh_adaptive() already grades the size change outward on its own.
for (const TriangleSelector::TriangleBitStreamMapping &m : data.triangles_to_split)
if (size_t(m.triangle_idx) < ntri)
region[m.triangle_idx] = 1;
if (painted_tri) {
TriangleSelector sel(mv->mesh());
sel.deserialize(data, false);
(*painted_tri)[slot].assign(ntri, 0);
for (const stl_triangle_vertex_indices &t : sel.get_facets_strict(EnforcerBlockerType::ENFORCER).indices) {
// A sub-triangle produced by a *partial* stroke always carries at least one appended
// (split) vertex, so "all three indices are original" is exactly the test for a whole,
// fully-painted triangle - the only kind whose paint can be inherited wholesale.
if (size_t(t[0]) >= nvert || size_t(t[1]) >= nvert || size_t(t[2]) >= nvert)
continue;
std::array<int, 3> k{ t[0], t[1], t[2] };
std::sort(k.begin(), k.end());
if (auto it = tri_by_verts.find(k); it != tri_by_verts.end())
(*painted_tri)[slot][it->second] = 1;
}
}
any_paint = true;
}
return any_paint;
}
void GLGizmoTextureDisplacement::subdivide_model_adaptive()
{
ModelVolume *mv = texture_volume();
ModelObject *mo = m_c->selection_info()->model_object();
if (mv == nullptr || mo == nullptr || m_subdivide_target_mm <= 0.f)
return;
update_model_object(); // flush any in-progress stroke into the committed masks first
std::vector<uint8_t> region;
std::array<std::vector<uint8_t>, TEXTURE_DISPLACEMENT_MAX_LAYERS> painted_tri;
if (!collect_paint_region(region, &painted_tri)) {
show_error(nullptr, _u8L("Paint the area you want to subdivide first - adaptive subdivision only "
"refines where you have painted."));
return;
}
// Feature-adaptive: sample the combined displacement so refinement follows texture curvature. A
// null sampler (only LSCM layers, or nothing decodable) falls back to the uniform target below.
HeightFieldSampler sampler;
if (m_subdivide_feature) {
TextureDisplacementFacetsData facets{};
for (int i = 0; i < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++i)
facets[size_t(i)] = mv->texture_displacement_facet(i).get_data();
sampler = make_combined_displacement_sampler(mv->mesh().its, mv->texture_displacement_layers, facets);
}
// Do the (potentially slow) refinement before taking the snapshot, so a no-op leaves no empty
// undo step - mirrors remesh_model().
// "Min edge" is a feature-mode control (it is the floor the curvature test refines down to); in
// plain adaptive mode the target edge length is the only criterion, so the floor must not be
// allowed to silently override a target the user set below it.
const float tol = m_subdivide_feature ? m_subdivide_detail_mm : 0.f;
const float floor = m_subdivide_feature ? m_subdivide_min_edge_mm : 0.f;
std::vector<int> source;
indexed_triangle_set refined;
{
wxBusyCursor wait;
// The budget slider is "triangles the refinement may *add*", so the model's own count is the
// baseline - otherwise the control would be meaningless (or a dead end) on a dense model.
refined = subdivide_mesh_adaptive(mv->mesh().its, region, m_subdivide_target_mm,
int(mv->mesh().its.indices.size()) + m_subdivide_budget_k * 1000,
&source, sampler, tol, floor);
}
if (refined.indices.size() == mv->mesh().its.indices.size()) {
show_error(nullptr, _u8L("Nothing to subdivide - the painted area already meets the target edge "
"length and detail tolerance, or the triangle budget is already used up."));
return;
}
Plater *plater = wxGetApp().plater();
Plater::TakeSnapshot snapshot(plater, _u8L("Adaptive subdivide for texture displacement"), UndoRedo::SnapshotType::GizmoAction);
// Other paint channels ride across via the standard remap; texture-displacement paint is rebuilt
// by hand below from the source map, which is the whole point of driving this by the paint.
std::optional<TriangleSelector::SavedPainting> saved_painting = mv->save_painting();
mv->set_mesh(TriangleMesh(std::move(refined))); // refined is not needed past here; source carries the paint map
mv->set_new_unique_id();
mv->calculate_convex_hull();
mv->restore_painting(saved_painting); // resets extra facets (incl. texture-displacement) + remaps the rest
// Carry each layer's paint onto the new mesh: a new triangle is painted iff its source triangle
// was fully painted in that layer. Children inherit their parent's source, so this is exact.
for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot) {
if (painted_tri[slot].empty())
continue;
TriangleSelector sel(mv->mesh());
for (size_t i = 0; i < source.size(); ++i)
if (painted_tri[slot][source[i]])
sel.set_facet(int(i), EnforcerBlockerType::ENFORCER);
mv->texture_displacement_facet(slot).set(sel);
}
if (ObjectList *obj_list = wxGetApp().obj_list()) {
const ModelObjectPtrs &objs = plater->model().objects;
auto it = std::find(objs.begin(), objs.end(), mo);
if (it != objs.end())
obj_list->update_info_items(size_t(it - objs.begin()));
}
plater->changed_object(*mo);
update_from_model_object(false); // reload selectors/preview against the new mesh + carried paint
m_parent.set_as_dirty();
}
void GLGizmoTextureDisplacement::smooth_model()
{
ModelVolume *mv = texture_volume();
ModelObject *mo = m_c->selection_info()->model_object();
if (mv == nullptr || mo == nullptr)
return;
const TextureDisplacementOptions &opts = mv->texture_displacement_options;
if (opts.smooth_strength <= 0.f || opts.smooth_iterations <= 0)
return;
update_model_object(); // flush any in-progress stroke, so the painted region below is current
// Movable = the vertices of the painted triangles, so the first ring of purely unpainted vertices
// outside them stays put and anchors the result. Restricted rather than whole-model on purpose:
// this runs on geometry that has already been baked, and relaxing the whole thing would quietly
// round off every unrelated feature on the part. With "Ignore outer ring" the patch's own rim is
// held as well - see TextureDisplacementOptions::smooth_skip_border.
const indexed_triangle_set &its = mv->mesh().its;
std::vector<uint8_t> painted_face(its.indices.size(), 0);
bool any = false;
for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot)
for (const TriangleSelector::TriangleBitStreamMapping &m : mv->texture_displacement_facet(slot).get_data().triangles_to_split)
if (size_t(m.triangle_idx) < its.indices.size()) {
painted_face[size_t(m.triangle_idx)] = 1;
any = true;
}
if (!any) {
show_error(nullptr, _u8L("Paint the area you want to smooth first - smoothing only touches the "
"painted part of the model."));
return;
}
std::vector<uint8_t> movable(its.vertices.size(), 0);
for (size_t i = 0; i < its.indices.size(); ++i)
if (painted_face[i])
for (int k = 0; k < 3; ++k)
movable[size_t(its.indices[i][k])] = 1;
if (opts.smooth_skip_border)
for (size_t i = 0; i < its.indices.size(); ++i)
if (!painted_face[i])
for (int k = 0; k < 3; ++k)
movable[size_t(its.indices[i][k])] = 0; // also used by unpainted geometry -> the rim
if (std::none_of(movable.begin(), movable.end(), [](uint8_t m) { return m != 0; })) {
// Every painted vertex is on the patch's rim, so "Ignore outer ring" leaves nothing to move.
show_error(nullptr, _u8L("Nothing to smooth - the painted area is only one triangle deep, so with "
"\"Ignore outer ring\" on there are no interior vertices to relax."));
return;
}
indexed_triangle_set smoothed = its;
{
wxBusyCursor wait;
smooth_mesh_vertices(smoothed, movable, opts.smooth_strength, opts.smooth_iterations);
}
Plater *plater = wxGetApp().plater();
Plater::TakeSnapshot snapshot(plater, _u8L("Smooth texture displacement"), UndoRedo::SnapshotType::GizmoAction);
// No save/restore-painting dance here, unlike subdivide and remesh: smoothing only moves vertices,
// it does not touch the triangle list, so every paint channel still refers to exactly the triangles
// it did before. set_mesh() clears the extra facets, so this saves and puts back the
// texture-displacement masks verbatim - no remap needed, and none of them is lost.
std::optional<TriangleSelector::SavedPainting> saved_painting = mv->save_painting();
std::array<TriangleSelector::TriangleSplittingData, TEXTURE_DISPLACEMENT_MAX_LAYERS> saved_texture;
for (int i = 0; i < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++i)
saved_texture[size_t(i)] = mv->texture_displacement_facet(i).get_data();
mv->set_mesh(TriangleMesh(std::move(smoothed)));
mv->set_new_unique_id();
mv->calculate_convex_hull();
mv->restore_painting(saved_painting);
for (int i = 0; i < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++i)
mv->texture_displacement_facet(i).set_data(std::move(saved_texture[size_t(i)]));
if (ObjectList *obj_list = wxGetApp().obj_list()) {
const ModelObjectPtrs &objs = plater->model().objects;
auto it = std::find(objs.begin(), objs.end(), mo);
if (it != objs.end())
obj_list->update_info_items(size_t(it - objs.begin()));
}
plater->changed_object(*mo);
update_from_model_object(false);
m_parent.set_as_dirty();
}
void GLGizmoTextureDisplacement::remesh_model()
{
ModelVolume *mv = texture_volume();
ModelObject *mo = m_c->selection_info()->model_object();
if (mv == nullptr || mo == nullptr || m_remesh_target_edge_mm <= 0.f)
return;
Plater *plater = wxGetApp().plater();
// CGAL isotropic remeshing can be slow on a big mesh; do it before taking the snapshot so a failure
// (it returns the input unchanged) doesn't leave an empty undo step.
const indexed_triangle_set &src = mv->mesh().its;
indexed_triangle_set remeshed;
{
wxBusyCursor wait;
remeshed = MeshBoolean::cgal::remesh_isotropic(mv->mesh().its, double(m_remesh_target_edge_mm), 3,
m_remesh_keep_sharp_edges ? double(m_remesh_sharp_angle_deg) : 0.0);
}
// remesh_isotropic() signals failure by handing the input straight back, so compare against it
// structurally. Vertex count alone is not enough: a remesh that only redistributes triangles at
// roughly the current density legitimately lands on the same count, and treating that as failure
// meant a perfectly good result got thrown away with an error message.
const bool unchanged = remeshed.indices.empty() ||
(remeshed.vertices.size() == src.vertices.size() && remeshed.indices.size() == src.indices.size() &&
remeshed.indices == src.indices);
if (unchanged) {
show_error(nullptr, _u8L("Remeshing did not change the model. It may be non-manifold (open edges or "
"edges shared by more than two triangles), or the target edge length may "
"already be met."));
return;
}
Plater::TakeSnapshot snapshot(plater, _u8L("Remesh model for texture displacement"), UndoRedo::SnapshotType::GizmoAction);
// Same save/replace/restore-painting dance as subdivide: texture-displacement paint has no remap
// across a topology change, so it is dropped rather than left pointing at triangles that moved.
std::optional<TriangleSelector::SavedPainting> saved_painting = mv->save_painting();
mv->set_mesh(TriangleMesh(std::move(remeshed)));
mv->set_new_unique_id();
mv->calculate_convex_hull();
mv->restore_painting(saved_painting);
if (ObjectList *obj_list = wxGetApp().obj_list()) {
const ModelObjectPtrs &objs = plater->model().objects;
auto it = std::find(objs.begin(), objs.end(), mo);
if (it != objs.end())
obj_list->update_info_items(size_t(it - objs.begin()));
}
plater->changed_object(*mo);
update_from_model_object(false);
m_parent.set_as_dirty();
}
void GLGizmoTextureDisplacement::rebuild_subdivide_preview()
{
m_subdivide_preview_glmodel.reset();
m_subdivide_preview_tris = -1;
const ModelVolume *mv = texture_volume();
if (mv == nullptr)
return;
// The same subdivision Apply would commit, kept in a throwaway mesh and shown only as a
// wireframe - the model itself is not touched until Apply.
indexed_triangle_set its;
if (m_subdivide_adaptive) {
if (m_subdivide_target_mm <= 0.f)
return;
std::vector<uint8_t> region;
if (!collect_paint_region(region, nullptr))
return; // nothing painted yet: nothing to preview
HeightFieldSampler sampler;
if (m_subdivide_feature) {
TextureDisplacementFacetsData facets{};
for (int i = 0; i < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++i)
facets[size_t(i)] = mv->texture_displacement_facet(i).get_data();
sampler = make_combined_displacement_sampler(mv->mesh().its, mv->texture_displacement_layers, facets);
}
// Feature mode: curvature (Detail tolerance) on top of the Max-edge baseline, down to the
// Min-edge floor. Plain adaptive: tol 0, so only the target-edge-length criterion applies.
const float tol = m_subdivide_feature ? m_subdivide_detail_mm : 0.f;
const float floor = m_subdivide_feature ? m_subdivide_min_edge_mm : 0.f;
its = subdivide_mesh_adaptive(mv->mesh().its, region, m_subdivide_target_mm,
int(mv->mesh().its.indices.size()) + m_subdivide_budget_k * 1000,
nullptr, sampler, tol, floor);
} else {
if (m_subdivide_count < 1)
return;
its = subdivide_mesh_uniform(mv->mesh().its, 0.f, m_subdivide_count);
}
if (its.indices.empty())
return;
m_subdivide_preview_tris = int(its.indices.size());
GLModel::Geometry init_data;
init_data.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
init_data.reserve_vertices(its.vertices.size());
init_data.reserve_indices(its.indices.size() * 6);
for (const Vec3f &v : its.vertices)
init_data.add_vertex(v);
for (const stl_triangle_vertex_indices &tri : its.indices)
for (int i = 0; i < 3; ++i)
init_data.add_line(unsigned(tri[i]), unsigned(tri[(i + 1) % 3]));
if (!init_data.is_empty())
m_subdivide_preview_glmodel.init_from(std::move(init_data));
}
void GLGizmoTextureDisplacement::render_subdivide_preview()
{
const ModelObject *mo = m_c->selection_info()->model_object();
const ModelVolume *mv = texture_volume();
if (mo == nullptr || mv == nullptr || !m_subdivide_preview_glmodel.is_initialized())
return;
GLShaderProgram *shader = wxGetApp().get_shader("flat");
if (shader == nullptr)
return;
const Selection &selection = m_parent.get_selection();
const Transform3d trafo_matrix = mo->instances[selection.get_instance_idx()]->get_transformation().get_matrix() * mv->get_matrix();
const Camera &camera = wxGetApp().plater()->get_camera();
shader->start_using();
shader->set_uniform("view_model_matrix", camera.get_view_matrix() * trafo_matrix);
shader->set_uniform("projection_matrix", camera.get_projection_matrix());
glsafe(::glEnable(GL_POLYGON_OFFSET_LINE));
glsafe(::glPolygonOffset(-1.0f, -1.0f));
m_subdivide_preview_glmodel.set_color(ColorRGBA(0.2f, 0.9f, 1.0f, 0.7f)); // cyan, reads as "preview"
m_subdivide_preview_glmodel.render();
glsafe(::glDisable(GL_POLYGON_OFFSET_LINE));
shader->stop_using();
}
GLTexture *GLGizmoTextureDisplacement::get_layer_thumbnail(const TextureDisplacementLayer &layer)
{
if (layer.empty() || layer.slot < 0 || size_t(layer.slot) >= TEXTURE_DISPLACEMENT_MAX_LAYERS)
return nullptr;
const size_t slot = size_t(layer.slot);
if (m_thumbnails[slot] && m_thumbnail_source[slot] == layer.image_data.get() &&
m_thumbnail_smoothing[slot] == layer.smoothing)
return m_thumbnails[slot].get();
// Reuses the already-decoded, already-cached grayscale pixels (see decode_height_texture()'s
// own cache in TextureDisplacement.cpp) - only the gray-to-RGBA expansion and GPU upload below are
// new work. Rebuilt when the texture *or the smoothing* changes, so the fast/bump preview - which
// samples this GPU texture directly - reflects the current smoothing rather than the raw image.
std::unique_ptr<GLTexture> texture = upload_height_thumbnail(decode_height_texture(layer));
if (!texture)
return nullptr;
m_thumbnails[slot] = std::move(texture);
m_thumbnail_source[slot] = layer.image_data.get();
m_thumbnail_smoothing[slot] = layer.smoothing;
return m_thumbnails[slot].get();
}
void GLGizmoTextureDisplacement::bake()
{
ModelVolume *mv = texture_volume();
if (!mv || m_bake_in_progress)
return;
// Make sure the currently active layer's in-progress edits are flushed into the model before
// baking, otherwise the most recent, not-yet-committed strokes would be silently skipped.
update_model_object();
if (!mv->is_texture_displacement_painted()) {
show_error(nullptr, _u8L("Nothing is painted, there is nothing to bake."));
return;
}
m_bake_in_progress = true;
queue_texture_displacement_bake(*mv, [this]() {
m_bake_in_progress = false;
// Baking replaces the volume's mesh (new id, new topology) without changing the object's
// id or volume count, so GLGizmoPainterBase::data_changed()'s usual change-detection never
// notices it needs to reload - do it explicitly here, otherwise the gizmo keeps painting
// and rendering against the stale, pre-bake TriangleSelectorPatch until the object is
// deselected and reselected.
if (m_state == On && m_c->selection_info() && m_c->selection_info()->model_object())
update_from_model_object(false);
m_parent.set_as_dirty();
});
}
void GLGizmoTextureDisplacement::render_paint_cursor_hint()
{
// Only in the plain paint/select modes; seam and adjust modes have their own click semantics where
// an add/remove sign would just be noise.
if (m_seam_edit_mode || m_adjust_texture_mode)
return;
const ImGuiIO &io = ImGui::GetIO();
// The pointer must be over the 3D view, not over this panel (or any other ImGui window).
if (io.WantCaptureMouse || !ImGui::IsMousePosValid())
return;
// Shift erases (see handle_snapshot_action_name()); a plain stroke adds.
const bool removing = io.KeyShift;
const ImU32 color = removing ? IM_COL32(235, 70, 60, 255) : IM_COL32(90, 210, 110, 255);
const char *glyph = removing ? "-" : "+";
ImDrawList *dl = ImGui::GetForegroundDrawList();
const float fs = ImGui::GetFontSize() * 1.5f;
const ImVec2 at(io.MousePos.x + 15.f, io.MousePos.y - fs - 6.f);
// A translucent dark disc behind the glyph so it reads on any material colour.
dl->AddCircleFilled(ImVec2(at.x + fs * 0.28f, at.y + fs * 0.5f), fs * 0.62f, IM_COL32(0, 0, 0, 150));
dl->AddText(ImGui::GetFont(), fs, at, color, glyph);
}
void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float bottom_limit)
{
ModelObject *mo = m_c->selection_info()->model_object();
if (!mo)
return;
ModelVolume *mv = texture_volume();
const float approx_height = m_imgui->scaled(24.f);
y = std::min(y, bottom_limit - approx_height);
// Docked (the default) the panel is pinned next to the gizmo toolbar and cannot be moved, like
// every other gizmo's. Undocked it becomes an ordinary floating window: a title bar to drag it
// by, and no forced position - this panel is tall enough (layer stack, per-layer controls) that
// it can cover the very part of the model being painted, and being able to shove it aside is the
// point. The position is deliberately *not* seeded on undock, so the window stays exactly where
// it already was and the user just gains the ability to move it from there.
ImGuiWindowFlags flags = ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse;
if (!m_undocked) {
flags |= ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar;
GizmoImguiSetNextWIndowPos(x, y, ImGuiCond_Always, 1.0f, 0.0f);
}
ImGuiWrapper::push_toolbar_style(m_parent.get_scale());
GizmoImguiBegin(get_name(), flags);
// Combo drop-downs otherwise inherit ImGui's near-black default popup background; under the light
// theme that leaves the dark item text unreadable ("the dropbox is black"). Pushed only around each
// Combo below (never around a tooltip, whose own near-black default is what makes it readable).
const ImVec4 combo_popup_bg = wxGetApp().dark_mode() ? ImVec4(0.18f, 0.18f, 0.19f, 1.f)
: ImVec4(0.93f, 0.93f, 0.93f, 1.f);
const auto scoped_combo = [&](const char *id, int *v, const char *const items[], int n) {
ImGui::PushStyleColor(ImGuiCol_PopupBg, combo_popup_bg);
const bool changed = ImGui::Combo(id, v, items, n);
ImGui::PopStyleColor();
return changed;
};
// Icon toggle button shared by the selection-mode and view-mode rows, styled like the main toolbar:
// an inactive button shows the icon in the theme's normal (grey) monochrome, an active one shows it
// in its original colours. All icons are the same square size. Falls back to a text checkbox if the
// icon set could not be loaded, so the control is never lost.
ensure_panel_icons();
// Sized to match the 3D toolbar's icons exactly, rather than to the panel's font. It is the same
// expression GLCanvas3D::_update_toolbar_icons_scale() uses, and it is valid here because ImGui's
// DisplaySize is set from the canvas's pixel size (GLCanvas3D::_resize()) - so one ImGui unit is
// one canvas pixel, the very units the toolbar is drawn in. Deriving it rather than hard-coding a
// font multiple also keeps the two in step when the toolbar auto-fit shrinks its icons to make
// them fit a narrow window, which it does by lowering the same toolbar_icon_scale() read here.
const float icon_btn_sz = GLToolbar::Default_Icons_Size * wxGetApp().toolbar_icon_scale() * m_parent.get_scale();
// The icon SVGs carry their own border, so the ImGui button's own frame border and idle fill are
// suppressed here (FrameBorderSize 0 + transparent ImGuiCol_Button) to avoid a doubled border - the
// hover/active fill is left in place for feedback. Applied only around these gizmo icon buttons.
const auto push_borderless_icon_style = []() {
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.f);
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.f, 0.f, 0.f, 0.f));
};
const auto pop_borderless_icon_style = []() {
ImGui::PopStyleColor();
ImGui::PopStyleVar();
};
const auto icon_toggle = [&](int uid, const std::string &iconfile, bool active, const wxString &label,
const wxString &tip) -> bool {
bool clicked = false;
const auto it = m_panel_icon_map.find(iconfile);
ImGui::PushID(uid);
// color_wite_gray variants: [0] normal/grey, [1] original colour, [2] disabled.
if (it != m_panel_icon_map.end() && it->second.size() >= 2 && it->second[active ? 1 : 0]->is_valid()) {
const IconManager::Icon &ic = *it->second[active ? 1 : 0];
push_borderless_icon_style();
clicked = m_imgui->image_button((ImTextureID) (intptr_t) ic.tex_id, ImVec2(icon_btn_sz, icon_btn_sz),
ic.tl, ic.br, -1, ImVec4(0, 0, 0, 0), ImVec4(1, 1, 1, 1));
pop_borderless_icon_style();
} else {
bool v = active;
clicked = ImGui::Checkbox(label.ToUTF8().data(), &v);
}
ImGui::PopID();
if (ImGui::IsItemHovered())
m_imgui->tooltip(tip, m_imgui->scaled(18.f));
return clicked;
};
// Borderless icon button (non-toggle): always the grey monochrome variant. Falls back to a plain
// text button when the icon file is absent, so the control is never lost before the art lands.
const auto icon_button = [&](int uid, const std::string &iconfile, float sz, const wxString &label,
const wxString &tip) -> bool {
bool clicked = false;
const auto it = m_panel_icon_map.find(iconfile);
ImGui::PushID(uid);
if (it != m_panel_icon_map.end() && !it->second.empty() && it->second[0]->is_valid()) {
const IconManager::Icon &ic = *it->second[0];
push_borderless_icon_style();
clicked = m_imgui->image_button((ImTextureID) (intptr_t) ic.tex_id, ImVec2(sz, sz), ic.tl, ic.br, -1,
ImVec4(0, 0, 0, 0), ImVec4(1, 1, 1, 1));
pop_borderless_icon_style();
} else {
clicked = m_imgui->button(label);
}
ImGui::PopID();
if (!tip.empty() && ImGui::IsItemHovered())
m_imgui->tooltip(tip, m_imgui->scaled(18.f));
return clicked;
};
if (m_imgui->button(m_undocked ? _L("Dock panel") : _L("Undock panel")))
m_undocked = !m_undocked;
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Detach this panel so it can be dragged anywhere over the 3D view, or dock it "
"back beside the toolbar."),
m_imgui->scaled(20.f));
ImGui::Separator();
// Selection mode: which of TriangleSelector's existing click/brush mechanisms drives painting.
// "Face" and "Connected area" reuse the exact same underlying selection machinery every other
// paint gizmo already has (single-facet click, and angle-limited flood fill respectively) -
// just exposed here as an alternative to brushing, one triangle/region at a time.
m_imgui->text(_L("Selection mode"));
const bool is_brush_mode = m_tool_type == ToolType::BRUSH && m_cursor_type != TriangleSelector::CursorType::POINTER;
const bool is_face_mode = m_tool_type == ToolType::BRUSH && m_cursor_type == TriangleSelector::CursorType::POINTER;
const bool is_area_mode = m_tool_type == ToolType::SMART_FILL;
ImGui::SameLine();
if (icon_toggle(801, "toolbar_big_brush.svg", is_brush_mode, _L("Brush"),
_L("Brush - paint over the surface by dragging"))) {
m_tool_type = ToolType::BRUSH;
m_cursor_type = TriangleSelector::CursorType::CIRCLE;
}
ImGui::SameLine();
if (icon_toggle(802, "toolbar_face.svg", is_face_mode, _L("Face"),
_L("Face - click individual triangles"))) {
m_tool_type = ToolType::BRUSH;
m_cursor_type = TriangleSelector::CursorType::POINTER;
}
ImGui::SameLine();
if (icon_toggle(803, "texture_displacement_connected_area.svg", is_area_mode, _L("Connected area"),
_L("Connected area - flood-fill the region reachable without crossing an edge sharper than the "
"angle threshold"))) {
m_tool_type = ToolType::SMART_FILL;
m_cursor_type = TriangleSelector::CursorType::POINTER;
}
if (is_brush_mode) {
m_imgui->text(m_desc.at("cursor_size"));
ImGui::SameLine();
ImGui::PushItemWidth(m_imgui->scaled(8.4f));
m_imgui->slider_float("##cursor_radius", &m_cursor_radius, CursorRadiusMin, CursorRadiusMax, "%.2f");
ImGui::PopItemWidth();
bool is_circle = m_cursor_type == TriangleSelector::CursorType::CIRCLE;
if (ImGui::RadioButton(m_desc.at("circle").ToUTF8().data(), is_circle))
m_cursor_type = TriangleSelector::CursorType::CIRCLE;
ImGui::SameLine();
if (ImGui::RadioButton(m_desc.at("sphere").ToUTF8().data(), !is_circle))
m_cursor_type = TriangleSelector::CursorType::SPHERE;
} else if (is_area_mode) {
ImGui::PushItemWidth(m_imgui->scaled(8.4f));
m_imgui->slider_float(_u8L("Angle threshold"), &m_smart_fill_angle, SmartFillAngleMin, SmartFillAngleMax, "%.0f");
ImGui::PopItemWidth();
}
if (m_imgui->button(_u8L("Select whole model")))
select_whole_model();
// View mode (#: "make View Mode with just icons"): Normal / Fast / Checker / Distortion behave as
// one radio group, Wireframe as an independent toggle. Each has its own icon; the tooltip carries
// the meaning. The underlying state stays m_use_bump_preview + m_uv_check_mode.
{
const int cur_mode = m_use_bump_preview ? 1 :
(m_uv_check_mode == UVCheckMode::Checker ? 2 :
m_uv_check_mode == UVCheckMode::Distortion ? 3 : 0);
int new_mode = cur_mode;
bool wf_toggle = false;
m_imgui->text(_L("View"));
ImGui::SameLine();
if (icon_toggle(701, "texture_displacement_real_preview.svg", cur_mode == 0, _L("Normal"),
_L("Normal - the true displaced geometry (what Bake produces)"))) new_mode = 0;
ImGui::SameLine();
if (icon_toggle(702, "texture_displacement_fast_preview.svg", cur_mode == 1, _L("Fast"),
_L("Fast - a bump-shaded approximation of the active layer only; quick to update, not exact"))) new_mode = 1;
ImGui::SameLine();
if (icon_toggle(703, "texture_displacement_checker.svg", cur_mode == 2, _L("Checker"),
_L("Checker - a test grid over the unwrap; squares stay square where it does not stretch"))) new_mode = 2;
ImGui::SameLine();
if (icon_toggle(704, "texture_displacement_distortion.svg", cur_mode == 3, _L("Distortion"),
_L("Distortion - blue-to-red stretch heatmap over the unwrap (needs the Unwrap/LSCM projection)"))) new_mode = 3;
ImGui::SameLine();
ImGui::Dummy(ImVec2(m_imgui->scaled(0.6f), 0.f));
ImGui::SameLine();
if (icon_toggle(705, "texture_displacement_wireframe.svg", m_wireframe_overlay, _L("Wireframe"),
_L("Wireframe - overlay the mesh edges; independent of the view above"))) wf_toggle = true;
if (new_mode != cur_mode) {
m_use_bump_preview = (new_mode == 1);
m_uv_check_mode = (new_mode == 2) ? UVCheckMode::Checker :
(new_mode == 3) ? UVCheckMode::Distortion : UVCheckMode::None;
rebuild_uvcheck_mesh();
if (m_use_bump_preview)
rebuild_bump_preview_mesh();
refresh_wireframe(); // Normal<->Fast swaps the wireframe between displaced and base mesh
update_uv_editor(); // mirror the checker / distortion heatmap into the UV pane too (#7)
m_parent.set_as_dirty();
}
if (wf_toggle) {
m_wireframe_overlay = !m_wireframe_overlay;
refresh_wireframe();
m_parent.set_as_dirty();
}
}
if (ImGui::Checkbox(_u8L("Auto update").c_str(), &m_auto_update))
if (m_auto_update)
rebuild_preview(); // catch up anything that changed while it was off
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Rebuild the displaced geometry as soon as anything changes (painting, textures, "
"sliders). Turn off to only rebuild when you release a slider, on very heavy models."),
m_imgui->scaled(20.f));
ImGui::Separator();
m_imgui->text(_L("Texture layers"));
if (mv != nullptr) {
// Add-layer affordance as an icon beside the heading. It is deliberately *not* right-aligned
// against the window edge: this panel uses ImGuiWindowFlags_AlwaysAutoResize, and positioning
// an item at GetWindowContentRegionMax().x - w feeds the window's own width back into its
// auto-fit, growing it by one item-spacing every frame - which, with the panel docked and
// anchored by its right edge, walked it left off-screen on hover. A plain SameLine can't do that.
const unsigned int add_icon = tool_icon_id();
const float sz = m_imgui->scaled(1.3f);
ImGui::SameLine();
bool add_clicked;
if (add_icon != 0) {
// The add icon SVG carries its own border; suppress the ImGui frame border/idle fill.
push_borderless_icon_style();
add_clicked = m_imgui->image_button((ImTextureID) (intptr_t) add_icon, ImVec2(sz, sz));
pop_borderless_icon_style();
} else {
add_clicked = m_imgui->button(m_desc.at("add_texture"));
}
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Add a texture layer"), m_imgui->scaled(20.f));
if (add_clicked)
add_texture_layer();
}
if (mv != nullptr) {
std::vector<TextureDisplacementLayer *> ordered;
for (TextureDisplacementLayer &l : mv->texture_displacement_layers)
ordered.push_back(&l);
std::sort(ordered.begin(), ordered.end(), [](const auto *a, const auto *b) { return a->slot < b->slot; });
// Removing a layer erases it from mv->texture_displacement_layers, which shifts every later
// element down and leaves `ordered` - and `layer` itself - pointing at the wrong element
// (or past the end). Removing mid-loop would therefore keep rendering this row's remaining
// widgets against freed/shifted memory. Defer it to after the loop instead.
int slot_to_remove = -1;
// The layer stack lives in its own scrolling, tinted region (#10, #12): with eight layers'
// worth of controls the panel otherwise runs off the bottom of the screen, and there was
// nothing to tell "settings that belong to this layer" apart from "settings that belong to
// the tool".
ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(1.f, 1.f, 1.f, 0.04f));
ImGui::BeginChild("##texture_layers", ImVec2(0.f, m_imgui->scaled(20.f)), true);
for (size_t li = 0; li < ordered.size(); ++li) {
TextureDisplacementLayer *layer = ordered[li];
ImGui::PushID(layer->slot);
const bool is_active = layer->slot == m_active_layer_slot;
// Tint the whole active layer's block, not just its header (#: "background color for the
// selected layer ... whole plate"). The block's height isn't known until it is laid out, so
// draw the block into a foreground channel and the backing rectangle into a background one,
// then merge - the standard ImGui "rect behind a group" trick.
ImDrawList *dl = ImGui::GetWindowDrawList();
const ImVec2 block_min = ImGui::GetCursorScreenPos();
const float block_rx = ImGui::GetWindowPos().x + ImGui::GetWindowContentRegionMax().x;
if (is_active) {
dl->ChannelsSplit(2);
dl->ChannelsSetCurrent(1);
}
// Clicking the header - or anywhere in the layer's block, see the group below - makes
// it the active layer (#11, #12). A radio button was doing this before, which worked but
// gave no sense of which block of controls belonged to which layer.
ImGui::PushStyleColor(ImGuiCol_Header, ImVec4(0.f, 0.68f, 0.58f, 0.55f));
ImGui::PushStyleColor(ImGuiCol_HeaderHovered, ImVec4(0.f, 0.68f, 0.58f, 0.35f));
const std::string header = layer->name.empty() ? Slic3r::format(_u8L("Layer %1%"), li + 1) : layer->name;
if (ImGui::Selectable(header.c_str(), is_active, 0, ImVec2(ImGui::GetContentRegionAvail().x - m_imgui->scaled(3.f), 0.f)))
set_active_layer(layer->slot);
ImGui::PopStyleColor(2);
ImGui::SameLine();
if (icon_button(600 + layer->slot, "texture_displacement_cross.svg", m_imgui->scaled(1.3f),
m_desc.at("remove_layer"), _u8L("Remove this layer")))
slot_to_remove = layer->slot;
// Everything below is this layer's own; the group lets a click anywhere inside it select
// the layer, which is what makes the block feel like one object rather than loose widgets.
ImGui::BeginGroup();
render_texture_picker(*layer);
ImGui::PushItemWidth(m_imgui->scaled(8.4f));
// Depth and tile size are logarithmic: see ImGuiLogSlider.
m_preview_params_dirty |= m_imgui->slider_float(_u8L("Depth (mm)"), &layer->depth_mm, 0.01f, 10.f, "%.3f", ImGuiLogSlider);
m_preview_params_dirty |= m_imgui->slider_float(_u8L("Tile size (mm)"), &layer->tiling_scale, 0.2f, 200.f, "%.2f", ImGuiLogSlider);
m_preview_params_dirty |= m_imgui->slider_float(_u8L("Rotation"), &layer->rotation_deg, 0.f, 360.f, "%.0f");
// Midlevel (#19): the height that means "don't move". At 0 the surface only ever bulges
// outwards; at 0.5 mid-grey is neutral and darker texels cut inwards.
m_preview_params_dirty |= m_imgui->slider_float(_u8L("Midlevel"), &layer->midlevel, 0.f, 10.f, "%.2f");
ImGui::PopItemWidth();
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("The grey level that stays put. At 0 the texture can only push the surface "
"outwards. Raise it and anything darker cuts inwards instead, so one height "
"map both embosses and engraves -0.5 makes mid-grey neutral.\n\n"
"Cutting inwards can fold the surface through itself where normals converge: "
"inside a sharp concave corner, or through a thin wall. Keep Depth small "
"relative to the feature you are cutting into."),
m_imgui->scaled(20.f));
if (layer->midlevel > 0.f && layer->depth_mm > 1.f)
m_imgui->warning_text(_L("Deep inward displacement may self-intersect."));
ImGui::PushItemWidth(m_imgui->scaled(8.4f));
m_preview_params_dirty |= m_imgui->slider_float(_u8L("Smoothing"), &layer->smoothing, 0.f, 1.f, "%.2f");
ImGui::PopItemWidth();
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Blurs the height texture before it displaces the surface, rounding hard edges "
"and removing speckle without needing a softer source image. Affects the preview "
"and the bake alike."),
m_imgui->scaled(20.f));
// Edge smoothing: fade the displacement to flat toward the boundary of the painted area.
m_preview_params_dirty |= ImGui::Checkbox(_u8L("Edge smoothing").c_str(), &layer->edge_smoothing);
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Fade the relief to flat toward the edge of the painted area, so it blends into "
"the surrounding surface. A small amount only softens a thin band at the very "
"edge; the maximum flattens the whole painted face."),
m_imgui->scaled(20.f));
if (layer->edge_smoothing) {
ImGui::PushItemWidth(m_imgui->scaled(8.4f));
m_preview_params_dirty |= m_imgui->slider_float(_u8L("Edge amount"), &layer->edge_smoothing_amount,
0.02f, 1.f, "%.2f");
ImGui::PopItemWidth();
}
m_preview_params_dirty |= ImGui::Checkbox(_u8L("Invert").c_str(), &layer->invert);
// The lowest painted layer has nothing underneath it to combine with - it *is* the
// base - so a blend mode would be meaningless (and Multiply/Divide against an implicit
// zero would annihilate it). build_texture_displacement() forces the first layer to
// reach a given vertex to behave additively regardless; say so rather than offering a
// control that silently does nothing.
if (li == 0) {
ImGui::TextDisabled("%s", _u8L("Base layer").c_str());
} else {
m_imgui->text(_u8L("Blend"));
ImGui::SameLine();
const std::string blend_add = _u8L("Add");
const std::string blend_subtract = _u8L("Subtract");
const std::string blend_multiply = _u8L("Multiply");
const std::string blend_divide = _u8L("Divide");
const char *blend_items[] = { blend_add.c_str(), blend_subtract.c_str(), blend_multiply.c_str(),
blend_divide.c_str() };
int blend_mode = static_cast<int>(layer->blend_mode);
ImGui::PushItemWidth(m_imgui->scaled(8.4f));
if (scoped_combo("##blend_mode", &blend_mode, blend_items, IM_ARRAYSIZE(blend_items))) {
layer->blend_mode = static_cast<TextureBlendMode>(blend_mode);
m_preview_params_dirty = true;
}
ImGui::PopItemWidth();
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("How this layer combines with the layers below it, wherever they overlap. "
"Add and Subtract pile relief on or carve it away. Multiply and Divide "
"scale the relief underneath, which makes this layer act as a mask over "
"it - for those two, Depth is a gain, and a depth of 1 mm on a white "
"part of the texture leaves the layers below unchanged."),
m_imgui->scaled(20.f));
}
m_preview_params_dirty |= ImGui::Checkbox(_u8L("Tile").c_str(), &layer->tile_enabled);
if (layer->tile_enabled) {
ImGui::SameLine();
const std::string tile_method_repeat = _u8L("Repeat");
const std::string tile_method_mirrored = _u8L("Mirrored repeat");
const char *tile_method_items[] = { tile_method_repeat.c_str(), tile_method_mirrored.c_str() };
int tile_method = static_cast<int>(layer->tile_method);
ImGui::PushItemWidth(m_imgui->scaled(8.4f));
if (scoped_combo("##tile_method", &tile_method, tile_method_items, IM_ARRAYSIZE(tile_method_items))) {
layer->tile_method = static_cast<TextureTileMethod>(tile_method);
m_preview_params_dirty = true;
}
ImGui::PopItemWidth();
}
{
m_imgui->text(_u8L("Projection"));
ImGui::SameLine();
const std::string projection_triplanar = _u8L("Triplanar (blended)");
const std::string projection_cylindrical = _u8L("Cylindrical");
const std::string projection_spherical = _u8L("Spherical");
const std::string projection_lscm = _u8L("Unwrap (LSCM)");
const std::string projection_view = _u8L("From view");
const char *projection_items[] = { projection_triplanar.c_str(), projection_cylindrical.c_str(),
projection_spherical.c_str(), projection_lscm.c_str(),
projection_view.c_str() };
int projection_method = static_cast<int>(layer->projection_method);
ImGui::PushItemWidth(m_imgui->scaled(8.4f));
if (scoped_combo("##projection_method", &projection_method, projection_items, IM_ARRAYSIZE(projection_items))) {
const auto new_method = static_cast<TextureProjectionMethod>(projection_method);
// Capture the current view the moment "From view" is chosen, so it does something
// sensible immediately rather than projecting from a stale/default direction.
if (new_method == TextureProjectionMethod::ViewProjected &&
layer->projection_method != TextureProjectionMethod::ViewProjected)
capture_view_projection(*layer);
layer->projection_method = new_method;
m_preview_params_dirty = true;
}
ImGui::PopItemWidth();
if (ImGui::IsItemHovered())
m_imgui->tooltip(layer->projection_method == TextureProjectionMethod::LSCM ?
_u8L("Flattens the painted area and maps the texture onto it with as little "
"stretching as possible. The area is cut into pieces at its sharp edges "
"first (see Seam angle), so each piece can lie flat on its own.") :
_u8L("Triplanar projects the texture from all three axes at once and blends "
"between them, so a patch wrapping around a sharp edge has no seam. "
"Cylindrical and Spherical wrap the texture around the painted area's "
"own centre, for round shapes."),
m_imgui->scaled(20.f));
if (layer->projection_method == TextureProjectionMethod::LSCM) {
ImGui::PushItemWidth(m_imgui->scaled(8.4f));
m_preview_params_dirty |= m_imgui->slider_float(_u8L("Seam angle"), &layer->lscm_seam_angle_deg,
5.f, 90.f, "%.0f");
ImGui::PopItemWidth();
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Edges sharper than this are cut, and the pieces either side of them are "
"flattened separately. Lower it to cut more: each piece then lies flat "
"with less stretching, at the cost of the texture not running continuously "
"across the cut. Raise it to keep more of the area in one piece. Corners "
"of a box are 90 degrees, so the default cuts them apart; a smoothly "
"rounded surface stays whole."),
m_imgui->scaled(20.f));
if (ImGui::Checkbox(_u8L("Connect islands").c_str(), &layer->auto_connect_islands)) {
// Apply (or, when turned off, just stop re-applying) right away rather than
// waiting for the next re-unwrap.
if (layer->auto_connect_islands && !m_uv_editor_unwrap.empty()) {
std::vector<TextureIsland> net = compute_connected_net(m_uv_editor_unwrap);
if (net.size() == size_t(m_uv_editor_unwrap.chart_count)) {
if (layer->islands.size() < net.size())
layer->islands.resize(net.size());
for (size_t i = 0; i < net.size(); ++i)
layer->islands[i] = net[i];
}
}
m_preview_params_dirty = true;
}
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Lay the unwrap out as a connected net: pieces that share an edge are "
"unfolded next to each other (a cube becomes a joined net rather than six "
"loose squares). They stay separate islands, so you can still move any of "
"them by hand afterwards."),
m_imgui->scaled(20.f));
if (is_active) {
// Explicit unwrap (#: "Add unwrap button so it does not recompute on every
// change"). The LSCM solve runs only when this is pressed - painting, the seam
// angle slider and seam marking no longer trigger it - and the pane opens right
// afterwards. Re-press it to fold in any edits made since.
if (m_imgui->button(_u8L("Unwrap"))) {
m_uv_unwrap_pending = true;
m_uv_apply_connected_net = true; // a genuine re-unwrap may relayout the islands
m_show_uv_editor = true;
update_uv_editor();
}
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Flatten the painted area into UV islands and open the UV editor. The "
"unwrap is computed only when you press this, not on every edit - so "
"paint, change the seam angle or mark seams first, then press Unwrap to "
"see the result. Islands can then be moved, rotated and scaled."),
m_imgui->scaled(20.f));
// Select mode for the UV pane: whole islands, single vertices, or single edges.
// Vertex/Edge are free-form UV editing and feed the per-vertex overrides that the
// bake honours; Island is the move/rotate/scale-with-grouping behaviour.
if (!m_uv_editor_unwrap.empty()) {
m_imgui->text(_u8L("Select:"));
const auto set_uv_mode = [&](int mode) {
if (mode != m_uv_select_mode) {
m_uv_select_mode = mode;
if (UVEditorCanvas *c = wxGetApp().plater()->get_uv_editor_canvas())
c->set_select_mode(static_cast<UVEditorCanvas::SelectMode>(mode));
}
};
ImGui::SameLine();
if (icon_toggle(810, "texture_displacement_uv_select_island.svg", m_uv_select_mode == 0,
_L("Island"), _L("Island - move, rotate and scale whole islands")))
set_uv_mode(0);
ImGui::SameLine();
if (icon_toggle(811, "texture_displacement_uv_select_vertex.svg", m_uv_select_mode == 1,
_L("Vertex"), _L("Vertex - drag vertices to reshape; Shift/Ctrl to multi-select")))
set_uv_mode(1);
ImGui::SameLine();
if (icon_toggle(812, "texture_displacement_uv_select_edge.svg", m_uv_select_mode == 2,
_L("Edge"), _L("Edge - drag edges to reshape; Shift/Ctrl to multi-select")))
set_uv_mode(2);
if (!layer->lscm_uv_overrides.empty()) {
ImGui::SameLine();
if (m_imgui->button(_u8L("Clear UV edits"))) {
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Clear texture UV edits"),
UndoRedo::SnapshotType::GizmoAction);
layer->lscm_uv_overrides.clear();
m_uv_unwrap_pending = true; // re-solve so the pane drops the edited coords
update_uv_editor();
rebuild_preview();
}
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Discard all manual vertex/edge moves and return the unwrap to its "
"automatic shape."),
m_imgui->scaled(20.f));
}
}
// Manual seam marking (#9): a click mode that toggles mesh edges as seams.
bool seam_mode = m_seam_edit_mode;
if (ImGui::Checkbox(_u8L("Mark seams").c_str(), &seam_mode)) {
m_seam_edit_mode = seam_mode;
if (seam_mode)
m_adjust_texture_mode = false; // the two click modes are mutually exclusive
else {
m_seam_hover_edge = { -1, -1 }; // drop the hover highlight when leaving the mode
m_seam_hover_vertex = -1;
m_seam_hover_glmodel.reset();
m_seam_path_anchor = -1;
m_seam_anchor_glmodel.reset();
}
m_parent.set_as_dirty();
}
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Click edges on the model to cut the unwrap along them, like marking a "
"seam in Blender. The edge under the cursor is highlighted yellow; click "
"to mark it red. Click a marked (red) edge again to unmark it. Hold Ctrl "
"and drag to rotate the view. Painting is paused while this is on."),
m_imgui->scaled(20.f));
if (m_seam_edit_mode) {
// Shortest-path mode, for dense meshes: click two points, seam the whole path.
ImGui::SameLine();
bool path_mode = m_seam_path_mode;
if (ImGui::Checkbox(_u8L("Path").c_str(), &path_mode)) {
m_seam_path_mode = path_mode;
m_seam_path_anchor = -1;
m_seam_hover_edge = { -1, -1 }; // hover target type changes with the mode
m_seam_hover_vertex = -1;
m_seam_hover_glmodel.reset();
m_seam_anchor_glmodel.reset();
m_parent.set_as_dirty();
}
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Instead of clicking every edge, click a start point and then an end "
"point: the whole shortest path between them is seamed at once (green "
"marks the start). Each click extends the seam from the last point. "
"Best for dense meshes."),
m_imgui->scaled(20.f));
}
if (!layer->lscm_seam_edges.empty()) {
ImGui::SameLine();
if (m_imgui->button(_u8L("Clear seams"))) {
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Clear texture seams"),
UndoRedo::SnapshotType::GizmoAction);
layer->lscm_seam_edges.clear();
rebuild_preview();
}
}
// What the UV editor is actually showing. Cheap, and the only way to tell an
// unwrap that produced nothing apart from one merely framed off-screen. The
// island tools (snap, average scale, cut) and the gesture hints now live in the
// UV pane itself - its toolbar and status line - rather than here (#18).
if (m_uv_editor_unwrap.empty())
m_imgui->text(_u8L("Press Unwrap to flatten the painted area."));
else
m_imgui->text(Slic3r::format(_u8L("Unwrap: %1% islands, %2% faces, %3% verts."),
m_uv_editor_unwrap.chart_count, m_uv_editor_unwrap.indices.size(),
m_uv_editor_unwrap.uvs.size()));
}
}
if (layer->projection_method == TextureProjectionMethod::ViewProjected) {
// Re-capture the projector from wherever the camera is now (#6): orbit the model,
// press this, and the texture is re-laid from the new angle.
if (m_imgui->button(_u8L("Capture current view"))) {
capture_view_projection(*layer);
// Selecting the visible faces *after* capturing means the projector axes are
// already the ones the selection was made against - the two describe the
// same viewpoint, which is the whole point of the option.
if (m_project_only_visible && select_visible_faces() == 0)
show_error(nullptr, _u8L("Nothing is visible from this angle - turn the model to face the "
"part you want to project onto."));
m_preview_params_dirty = true;
update_projector();
}
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Projects the texture straight onto the painted area from the direction "
"you are currently looking, like a slide projector. Faces angled away from "
"that direction will stretch - turn the model to where you want the "
"texture crisp, then capture."),
m_imgui->scaled(20.f));
if (ImGui::Checkbox(_u8L("Project only on visible").c_str(), &m_project_only_visible)) {
if (m_project_only_visible && select_visible_faces() == 0)
show_error(nullptr, _u8L("Nothing is visible from this angle - turn the model to face the "
"part you want to project onto."));
m_preview_params_dirty = true;
update_projector();
}
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Paints exactly the faces you can currently see - facing the camera and "
"not hidden behind anything else - and projects onto those. This replaces "
"the layer's painted area, and is re-applied each time you capture the "
"view."),
m_imgui->scaled(20.f));
ImGui::Separator();
bool projector_open = m_projector_frame != nullptr && m_projector_frame->IsShown();
if (ImGui::Checkbox(_u8L("Projection frame").c_str(), &projector_open))
show_projector(projector_open);
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Opens a see-through window you drag over the model. Whatever shows "
"through it is what the texture is projected onto, and the window's "
"border becomes the edge of the projection. Move and resize it to frame "
"the area you want, then press Apply."),
m_imgui->scaled(20.f));
if (projector_open) {
ImGui::PushItemWidth(m_imgui->scaled(6.f));
if (ImGui::SliderInt(_u8L("Opacity").c_str(), &m_projector_opacity, 20, 255))
m_projector_frame->set_opacity(m_projector_opacity);
ImGui::PopItemWidth();
if (m_imgui->button(_u8L("Apply projection frame"))) {
const int painted = apply_projection_frame();
if (painted == 0)
show_error(nullptr, _u8L("Nothing of the model is inside the frame - move it over the "
"part you want to project onto."));
else if (painted < 0)
show_error(nullptr, _u8L("The frame could not be applied. Make sure it overlaps the "
"3D view."));
}
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Projects the texture through the frame from the direction you are "
"looking now, and paints the visible faces inside it. This replaces "
"the layer's painted area. The result is fixed to the model, so you "
"can orbit freely afterwards."),
m_imgui->scaled(20.f));
}
if (layer->view_project_projective) {
m_imgui->text(_u8L("Placed by projection frame."));
ImGui::SameLine();
if (m_imgui->button(_u8L("Clear"))) {
// Back to the plain axis projection, where tiling/rotation/offset mean
// something again - the matrix path deliberately ignores them.
layer->view_project_projective = false;
layer->tile_enabled = true;
m_preview_params_dirty = true;
}
}
}
}
if (is_active) {
bool adjust_on = m_adjust_texture_mode;
if (ImGui::Checkbox(_u8L("Adjust placement").c_str(), &adjust_on)) {
if (adjust_on) {
update_model_object(); // flush any pending strokes before anchoring
if (update_adjust_anchor())
m_adjust_texture_mode = true;
else
show_error(nullptr, _u8L("Paint something with this layer first."));
} else {
m_adjust_texture_mode = false;
m_adjust_drag_handle = AdjustHandle::None;
}
}
}
ImGui::EndGroup();
// A click that lands on the layer's body (not on a widget, which consumes its own click)
// selects it too, so the whole block reads as one clickable object (#12).
if (!is_active && ImGui::IsItemClicked())
set_active_layer(layer->slot);
if (is_active) {
const float pad = m_imgui->scaled(0.25f);
const ImVec2 rmin(block_min.x - pad, block_min.y - pad);
const ImVec2 rmax(block_rx, ImGui::GetCursorScreenPos().y);
dl->ChannelsSetCurrent(0);
dl->AddRectFilled(rmin, rmax, ImGui::GetColorU32(ImVec4(0.0f, 0.59f, 0.53f, 0.22f)), m_imgui->scaled(0.2f));
dl->ChannelsMerge();
}
ImGui::PopID();
ImGui::Separator();
}
ImGui::EndChild();
ImGui::PopStyleColor();
if (slot_to_remove >= 0)
remove_texture_layer(slot_to_remove); // deferred: see slot_to_remove's declaration
}
// ImGui sliders report "changed" continuously on every frame while being dragged, not just
// once on release - rebuilding the preview (a real CPU mesh recompute) on every one of those
// frames is what made dragging these sliders feel slow. Only rebuild once the mouse button
// that's driving the drag is released, i.e. once per edit instead of dozens of times per drag.
// The feature-adaptive subdivision follows the *displaced* surface (it samples depth * texture),
// so depth / tile-size / rotation / invert all change where it puts triangles. The heavy
// displacement preview below only rebuilds on release, which made the subdivide wireframe look
// like it ignored those edits - so rebuild it live here (during the drag), the same cadence its
// own sliders use. Cheap: it is bounded by the painted region.
if (m_preview_params_dirty && m_subdivide_editing && m_subdivide_adaptive && m_subdivide_feature)
rebuild_subdivide_preview();
if (m_preview_params_dirty && (m_auto_update || !ImGui::IsMouseDown(ImGuiMouseButton_Left))) {
rebuild_preview();
// Same edits (tile size, rotation, offset, a new texture) are what the projector window
// draws, so it refreshes on the same one-per-edit cadence. No-op while it is closed.
update_projector();
m_preview_params_dirty = false;
}
// (The "Add layer" button now lives next to the "Texture layers" heading, as an icon.)
// Settings for the whole stack rather than one layer, so they sit outside the layer list.
if (mv != nullptr) {
TextureDisplacementOptions &opts = mv->texture_displacement_options;
ImGui::Separator();
m_preview_params_dirty |= ImGui::Checkbox(_u8L("Displace up to the border").c_str(), &opts.displace_border);
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Move the outermost ring of painted vertices as well, so the relief runs all the "
"way to the edge of the painted area. Turn this off to hold that ring flat, which "
"keeps the displacement strictly inside the paint but flattens the pattern right "
"at the border."),
m_imgui->scaled(20.f));
m_preview_params_dirty |= ImGui::Checkbox(_u8L("Smooth result").c_str(), &opts.smooth_enabled);
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Relax the displaced surface after the textures have been applied, to round off "
"the hard steps a bitmap height map leaves behind. Only the vertices the "
"displacement moved are touched. This is geometry smoothing - the per-layer "
"\"Blur\" slider instead softens the height map before it is sampled."),
m_imgui->scaled(20.f));
if (opts.smooth_enabled) {
ImGui::PushItemWidth(m_imgui->scaled(8.4f));
float percent = opts.smooth_strength * 100.f;
if (m_imgui->slider_float(std::string(_u8L("Smoothing (%)")) + "##dispsmooth", &percent, 1.f, 100.f, "%.0f", 1.f)) {
opts.smooth_strength = std::clamp(percent / 100.f, 0.01f, 1.f);
m_preview_params_dirty = true;
}
if (ImGui::SliderInt((_u8L("Passes") + "##dispsmoothit").c_str(), &opts.smooth_iterations, 1, 10)) {
opts.smooth_iterations = std::clamp(opts.smooth_iterations, 1, 10);
m_preview_params_dirty = true;
}
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("How many relaxation passes to run. More passes reach further across the "
"surface; strength controls how much each one moves a vertex."),
m_imgui->scaled(20.f));
ImGui::PopItemWidth();
m_preview_params_dirty |= ImGui::Checkbox(_u8L("Ignore outer ring").c_str(), &opts.smooth_skip_border);
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Leave the outermost ring of painted vertices out of the smoothing. Their "
"neighbours outside the paint never move, so relaxing them drags the relief "
"back down and the pattern comes out half-melted right at the edge. Turn this "
"off only if you want that edge softened on purpose."),
m_imgui->scaled(20.f));
// The settings above ride along with Preview/Bake. This button is for geometry that has
// *already* been baked, where there is no displacement left to fold the smoothing into.
if (m_imgui->button(_u8L("Smooth baked mesh now")))
smooth_model();
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Apply the smoothing above to the model's real geometry right now, using the "
"painted area to decide what to touch. For relief that is already baked in - "
"unbaked displacement is smoothed by Bake itself."),
m_imgui->scaled(20.f));
}
}
ImGui::Separator();
m_imgui->text(_u8L("Not enough vertices for fine detail?"));
if (ImGui::Checkbox(_u8L("Only painted area (adaptive)").c_str(), &m_subdivide_adaptive)) {
if (m_subdivide_editing)
rebuild_subdivide_preview(); // switch the wireframe between the uniform and adaptive result
m_parent.set_as_dirty();
}
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Refine only where you have painted, down to a target edge length, instead of splitting "
"the whole model. Keeps the triangle count down on a big part with a small decal, and - "
"unlike whole-model subdivision - your paint is carried onto the finer mesh instead of "
"being cleared."),
m_imgui->scaled(20.f));
if (m_subdivide_adaptive) {
if (m_subdivide_target_mm <= 0.f && mv != nullptr) {
// Seed the target at about half the mesh's mean edge length, so the default already adds
// a useful amount of detail rather than landing on "no change".
const indexed_triangle_set &its = mv->mesh().its;
double sum = 0.0; size_t cnt = 0;
for (const stl_triangle_vertex_indices &tri : its.indices)
for (int i = 0; i < 3; ++i) {
sum += (its.vertices[tri[i]] - its.vertices[tri[(i + 1) % 3]]).norm();
++cnt;
}
m_subdivide_target_mm = cnt > 0 ? std::clamp(float(sum / double(cnt)) * 0.5f, 0.001f, 20.f) : 1.f;
}
// Live preview: rebuild the wireframe as the slider moves, not only on release, so it tracks
// the value. The rebuild is bounded by the painted region, so it stays responsive.
const auto preview_live = [this]() {
if (m_subdivide_editing)
rebuild_subdivide_preview();
m_parent.set_as_dirty();
};
if (ImGui::Checkbox(_u8L("Follow texture detail").c_str(), &m_subdivide_feature)) {
if (m_subdivide_editing)
rebuild_subdivide_preview();
m_parent.set_as_dirty();
}
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Put triangles only where the texture actually bends - dense over hills, ridges and "
"noise, sparse over flat areas and smooth slopes - instead of an even density "
"everywhere. Uses the combined displacement of all painted layers."),
m_imgui->scaled(20.f));
ImGui::PushItemWidth(m_imgui->scaled(8.4f));
// The edge-length target is a baseline in both modes. In feature mode it is what guarantees
// the curvature test can actually see the texture: left too coarse, a big triangle over a
// fine pattern can sample four points that all happen to land at similar heights, report no
// error, and stall before refinement ever starts. "##subdiv" avoids an ID clash with the
// remesh "Target edge (mm)" slider below (same label == same widget to ImGui).
if (m_imgui->slider_float(std::string(m_subdivide_feature ? _u8L("Max edge (mm)") : _u8L("Target edge (mm)")) +
"##subdiv",
&m_subdivide_target_mm, 0.001f, 20.f, "%.3f", ImGuiLogSlider))
preview_live();
if (ImGui::IsItemHovered())
m_imgui->tooltip(m_subdivide_feature ?
_u8L("Nothing in the painted area stays coarser than this, even where the texture is "
"flat. Keep it near the size of the features you want picked up - too coarse and "
"fine detail can be missed entirely.") :
_u8L("Triangles in the painted area are split until every edge is at or below this "
"length. Smaller means finer detail and more triangles."),
m_imgui->scaled(20.f));
if (m_subdivide_feature) {
// On top of the baseline: the chord-error tolerance, and the resolution floor.
if (m_imgui->slider_float(std::string(_u8L("Detail (mm)")) + "##subdivdetail", &m_subdivide_detail_mm,
0.001f, 1.f, "%.3f", ImGuiLogSlider))
preview_live();
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("How closely the mesh follows the texture's relief. Smaller captures finer bumps; "
"larger only chases the big features."),
m_imgui->scaled(20.f));
if (m_imgui->slider_float(std::string(_u8L("Min edge (mm)")) + "##subdivmin", &m_subdivide_min_edge_mm,
0.001f, 20.f, "%.3f", ImGuiLogSlider))
preview_live();
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("The finest triangle size refinement will ever produce. Smaller captures finer "
"relief; also stops runaway subdivision at a sharp texture step, where the "
"surface never becomes flat."),
m_imgui->scaled(20.f));
}
// The budget. Refinement is worst-error-first, so a run that hits it has still spent its
// triangles on the biggest deviations - raising it buys detail, it does not redistribute it.
if (ImGui::SliderInt((_u8L("Added triangles (k)") + "##subdivbudget").c_str(), &m_subdivide_budget_k, 10, 2000)) {
m_subdivide_budget_k = std::clamp(m_subdivide_budget_k, 10, 2000);
preview_live();
}
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("How many thousand triangles the refinement may add. It always splits the "
"worst-fitting triangle first, so a run that uses the whole budget has still spent "
"it where it shows most - raise this if the preview still looks too coarse."),
m_imgui->scaled(20.f));
ImGui::PopItemWidth();
if (m_subdivide_editing && m_subdivide_preview_tris > 0)
m_imgui->text(Slic3r::format(_u8L("Preview: %1% triangles"), m_subdivide_preview_tris));
} else {
ImGui::PushItemWidth(m_imgui->scaled(8.4f));
if (ImGui::SliderInt(_u8L("Subdivide steps").c_str(), &m_subdivide_count, 0, 5)) {
m_subdivide_count = std::clamp(m_subdivide_count, 0, 5);
if (m_subdivide_editing)
rebuild_subdivide_preview(); // a count of 0 clears the preview, it doesn't compute one
m_parent.set_as_dirty();
}
ImGui::PopItemWidth();
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("How many times to split every triangle into four. Each step roughly quadruples the "
"triangle count, so there are enough vertices for the height texture to displace. "
"0 means no subdivision."),
m_imgui->scaled(20.f));
}
// Apply is a no-op when there is nothing to commit: 0 uniform passes, or an adaptive target that
// is not set (the preview covers the painted-area check itself).
const bool subdivide_ready = m_subdivide_adaptive ? (m_subdivide_target_mm > 0.f) : (m_subdivide_count >= 1);
if (!m_subdivide_editing) {
if (m_imgui->button(_u8L("Preview subdivision"))) {
m_subdivide_editing = true;
rebuild_subdivide_preview();
m_parent.set_as_dirty();
}
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Shows the subdivided mesh as a wireframe without changing the model. Press Apply to "
"commit it, or Done to leave the model as it is."),
m_imgui->scaled(20.f));
} else {
m_imgui->disabled_begin(!subdivide_ready);
if (m_imgui->button(_u8L("Apply"))) {
if (m_subdivide_adaptive) {
subdivide_model_adaptive(); // refines only the painted area, carrying the paint forward
} else {
subdivide_model(); // commits m_subdivide_count passes (takes its own snapshot)
// Back to 0 rather than staying at the count just applied: the mesh is now up to 4^N
// times denser, so re-previewing the same N passes on top of it is both pointless (the
// density asked for is already committed) and by far the slowest thing this panel does.
m_subdivide_count = 0;
}
rebuild_subdivide_preview();
m_parent.set_as_dirty();
}
m_imgui->disabled_end();
if (ImGui::IsItemHovered())
m_imgui->tooltip(m_subdivide_adaptive ?
_u8L("Refines the painted area to the target edge length and carries your paint onto "
"the finer mesh. The rest of the model is left as it is.") :
_u8L("Replaces the model's geometry with the subdivided mesh and clears any not-yet-baked "
"paint on it (already-baked bumps are unaffected)."),
m_imgui->scaled(20.f));
ImGui::SameLine();
if (m_imgui->button(_u8L("Done"))) {
m_subdivide_editing = false;
m_subdivide_preview_tris = -1;
m_subdivide_preview_glmodel.reset();
m_parent.set_as_dirty();
}
}
// Remesh: even out uneven triangle sizes (CGAL isotropic remeshing). GPU Delaunay isn't practical
// here, but this delivers the same goal - a consistent triangle size across the whole model.
m_imgui->text(_u8L("Uneven triangle sizes?"));
if (m_remesh_target_edge_mm <= 0.f && mv != nullptr) {
// Seed the target with the model's current mean edge length, so the default is a sensible
// "make everything about the size it already averages".
const indexed_triangle_set &its = mv->mesh().its;
double sum = 0.0; size_t cnt = 0;
for (const stl_triangle_vertex_indices &tri : its.indices)
for (int i = 0; i < 3; ++i) {
sum += (its.vertices[tri[i]] - its.vertices[tri[(i + 1) % 3]]).norm();
++cnt;
}
m_remesh_target_edge_mm = cnt > 0 ? std::clamp(float(sum / double(cnt)), 0.1f, 20.f) : 1.f;
}
ImGui::PushItemWidth(m_imgui->scaled(8.4f));
m_imgui->slider_float(_u8L("Target edge (mm)"), &m_remesh_target_edge_mm, 0.1f, 20.f, "%.2f", ImGuiLogSlider);
ImGui::PopItemWidth();
ImGui::Checkbox(_u8L("Keep sharp edges").c_str(), &m_remesh_keep_sharp_edges);
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Holds hard edges and open borders in place while the rest is remeshed. Without it "
"the remesher slides vertices along the surface and rounds every crisp edge off - "
"a cube comes back with wobbly edges."),
m_imgui->scaled(20.f));
if (m_remesh_keep_sharp_edges) {
ImGui::PushItemWidth(m_imgui->scaled(8.4f));
m_imgui->slider_float(_u8L("Sharp edge angle"), &m_remesh_sharp_angle_deg, 5.f, 90.f, "%.0f deg");
ImGui::PopItemWidth();
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Edges bent by more than this count as hard features and are kept. Lower keeps "
"more detail but leaves more of the mesh untouched; higher remeshes more freely."),
m_imgui->scaled(20.f));
}
m_imgui->disabled_begin(mv == nullptr);
if (m_imgui->button(_u8L("Remesh")))
remesh_model();
m_imgui->disabled_end();
if (ImGui::IsItemHovered())
m_imgui->tooltip(_u8L("Rebuilds the whole model with triangles close to this edge length - splitting the big "
"ones and merging the small ones - so displacement has an even density to work with. "
"Replaces the geometry and clears any not-yet-baked paint (already-baked bumps are kept)."),
m_imgui->scaled(20.f));
ImGui::Separator();
m_imgui->disabled_begin(mv == nullptr || !mv->is_texture_displacement_painted());
if (m_imgui->button(m_desc.at("remove_all"))) {
Plater::TakeSnapshot snapshot(wxGetApp().plater(), _u8L("Reset texture displacement selection"), UndoRedo::SnapshotType::GizmoAction);
int idx = -1;
for (ModelVolume *v : mo->volumes)
if (v->is_model_part()) {
++idx;
m_triangle_selectors[idx]->reset();
m_triangle_selectors[idx]->request_update_render_data();
}
update_model_object();
m_parent.set_as_dirty();
}
m_imgui->disabled_end();
ImGui::SameLine();
m_imgui->disabled_begin(m_bake_in_progress || mv == nullptr || !mv->is_texture_displacement_painted());
if (m_imgui->button(m_bake_in_progress ? _L("Baking...") : m_desc.at("bake")))
bake();
m_imgui->disabled_end();
ImGui::Separator();
if (m_imgui->button(_L("Close")))
m_parent.reset_all_gizmos();
GizmoImguiEnd();
ImGuiWrapper::pop_toolbar_style();
// Drawn last, over everything, via the foreground draw list: the +/- add-remove sign next to the
// 3D cursor. Still inside the gizmo's ImGui frame here, which is what render_paint_cursor_hint() needs.
render_paint_cursor_hint();
}
} // namespace Slic3r::GUI
Reference in New Issue View Git Blame Copy Permalink