Slic3r::GUI::UVEditorCanvas Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/UVEditorCanvas.hpp>

Inheritance diagram for Slic3r::GUI::UVEditorCanvas:

Collaboration diagram for Slic3r::GUI::UVEditorCanvas:

Classes
struct	Islands
struct	PaneState

Public Types
enum class	Command {   FrameAll , ToggleSnap , AverageScale , CutSelectedIsland ,   ProjectFromView , JoinSelected , UnjoinSelected , Unwrap ,   SetSeamAngle , SetConnectIslands , SetSelectMode , SetMarkSeams ,   SetSeamPath , ClearSeams , ClearUVEdits , SetBackground ,   PickTexture , PaneClosed , SelectionChanged }
enum class	Background { Height , Checker , Distortion }
enum class	SelectMode { Island , Vertex , Edge }
using	IslandTransform = Eigen::Matrix<float, 2, 3>
using	CommandFn = std::function<void(Command, float)>
using	PaneStateFn = std::function<void(const PaneState &)>
using	StatusFn = std::function<void(const wxString &)>
using	IslandEditFn
using	UVVertexEditFn = std::function<void(const std::vector<std::pair<int, Vec2f>> &edits)>

Public Member Functions
	UVEditorCanvas (wxWindow *parent)
void	set_islands (Islands islands)
void	set_island_transforms (std::vector< IslandTransform > transforms)
void	set_island_fill_colors (std::vector< ColorRGBA > colors)
void	set_uv_transform (float tiling_scale, float rotation_deg, bool tile_enabled, bool tile_mirrored)
void	set_background_texture (const std::vector< unsigned char > &grayscale_pixels, int width, int height)
void	set_snap_enabled (bool enabled)
bool	snap_enabled () const
void	run_command (Command cmd, float value=0.f)
void	set_command_callback (CommandFn fn)
void	set_pane_state (PaneState state)
const PaneState &	pane_state () const
void	set_pane_state_callback (PaneStateFn fn)
void	set_status_callback (StatusFn fn)
void	set_island_edit_callback (IslandEditFn fn)
void	set_select_mode (SelectMode mode)
SelectMode	select_mode () const
void	set_vertex_edit_callback (UVVertexEditFn fn)
int	selected_island () const
bool	has_islands () const
const std::vector< int > &	selected_islands () const
void	reset_view ()
void	invalidate_gl ()

Private Types
enum class	Gesture {   None , Pan , MoveIsland , RotateIsland ,   RotateIslandModal , ScaleIslandModal , MoveVertex , MoveEdge }

Private Member Functions
void	on_paint (wxPaintEvent &evt)
void	on_size (wxSizeEvent &evt)
void	on_mouse (wxMouseEvent &evt)
void	on_capture_lost (wxMouseCaptureLostEvent &evt)
void	on_key (wxKeyEvent &evt)
void	on_leave (wxMouseEvent &evt)
void	on_erase_background (wxEraseEvent &evt)
void	render ()
void	rebuild_island_models ()
void	rebuild_background_texture ()
void	rebuild_background_quad ()
void	rebuild_grid ()
void	content_bounds (Vec2f &min_uv, Vec2f &max_uv) const
void	framed_bounds (Vec2f &min_uv, Vec2f &max_uv) const
void	fit_view_to_content ()
void	view_half_extents (float &half_w, float &half_h) const
Vec2f	screen_to_uv (const wxPoint &px) const
Vec2f	island_uv (size_t vertex) const
int	island_at (const Vec2f &uv) const
int	vertex_at (const Vec2f &uv) const
std::pair< int, int >	edge_at (const Vec2f &uv) const
void	move_vertex_raw (int unwrapped_vertex, const Vec2f &delta_uv)
Vec2f	island_centroid (int island) const
Vec2f	uv_delta_to_unwrap (const Vec2f &delta_uv) const
Vec2f	snap_correction (int island) const
void	end_gesture ()
void	cancel_gesture ()
void	grab_mouse ()
void	drop_mouse ()
void	update_status ()
void	update_hover (const wxPoint &pos)
bool	is_vertex_selected (int v) const
bool	is_edge_selected (const std::pair< int, int > &e) const
std::vector< int >	selected_edge_endpoints () const
bool	is_selected (int island) const
void	rebuild_rotation_dial ()
float	island_rotation_deg (int island) const

Private Attributes
wxGLContext *	m_context = nullptr
Islands	m_islands
std::vector< IslandTransform >	m_transforms
std::vector< ColorRGBA >	m_island_fill_colors
std::vector< std::vector< int > >	m_island_boundary_verts
std::vector< std::vector< std::pair< int, int > > >	m_island_boundary_edges
std::vector< std::vector< int > >	m_island_tris
std::vector< std::pair< Vec2f, Vec2f > >	m_island_raw_bounds
bool	m_mesh_dirty = true
bool	m_gl_reset_pending = false
std::vector< GLModel >	m_island_wireframe
std::vector< GLModel >	m_island_fill
GLModel	m_stroke_glmodel
GLModel	m_dim_quad_glmodel
int	m_stencil_bits = -1
GLModel	m_tile_outline_glmodel
GLModel	m_grid_glmodel
float	m_grid_step = 0.f
float	m_tiling_scale = 1.f
float	m_rotation_deg = 0.f
bool	m_tile_enabled = true
bool	m_tile_mirrored = false
bool	m_snap_enabled = false
std::vector< unsigned char >	m_background_pixels
int	m_background_width = 0
int	m_background_height = 0
bool	m_background_dirty = false
bool	m_background_quad_dirty = true
GLTexture	m_background_texture
GLModel	m_background_glmodel
Vec2f	m_pan = Vec2f(0.5f, 0.5f)
float	m_zoom = 0.75f
bool	m_needs_fit = true
Gesture	m_gesture = Gesture::None
SelectMode	m_select_mode = SelectMode::Island
int	m_active_vertex = -1
std::pair< int, int >	m_active_edge { -1, -1 }
std::vector< int >	m_sel_vertices
std::vector< std::pair< int, int > >	m_sel_edges
wxPoint	m_cursor_px { 0, 0 }
bool	m_cursor_inside = false
bool	m_vertex_edit_moved = false
GLModel	m_vertex_marker_glmodel
int	m_hover_island = -1
int	m_hover_vertex = -1
std::pair< int, int >	m_hover_edge { -1, -1 }
int	m_selected_island = -1
std::vector< int >	m_selection
wxPoint	m_drag_last_px
Vec2f	m_gesture_last_uv = Vec2f::Zero()
float	m_gesture_last_angle = 0.f
float	m_gesture_last_dist = 0.f
float	m_rot_raw_deg = 0.f
float	m_rot_applied_deg = 0.f
float	m_rot_base_deg = 0.f
float	m_rot_display_deg = 0.f
float	m_modal_scale_accum = 1.f
GLModel	m_dial_glmodel
IslandEditFn	m_on_island_edit
UVVertexEditFn	m_on_vertex_edit
CommandFn	m_on_command
StatusFn	m_on_status
PaneState	m_pane_state
PaneStateFn	m_on_pane_state

Detailed Description

---

Class Documentation

Slic3r::GUI::UVEditorCanvas::Islands

struct Slic3r::GUI::UVEditorCanvas::Islands

Collaboration diagram for Slic3r::GUI::UVEditorCanvas::Islands:

Class Members
vector< pair< int, int > >	boundary_edges
vector< Vec3i32 >	indices
int	island_count = 0
vector< Vec2f >	uvs
vector< int >	vertex_island

Slic3r::GUI::UVEditorCanvas::PaneState

struct Slic3r::GUI::UVEditorCanvas::PaneState

Collaboration diagram for Slic3r::GUI::UVEditorCanvas::PaneState:

Class Members
Background	background = Background::Height
bool	connect_islands = true
size_t	face_count = 0
bool	has_layer = false
bool	has_seams = false
bool	has_uv_edits = false
int	island_count = 0
wxString	layer_name
bool	mark_seams = false
float	seam_angle_deg = 40.f
bool	seam_path = false
int	thumbnail_px = 0
vector< unsigned char >	thumbnail_rgb
float	tile_mm = 0.f
bool	unwrap_stale = false
bool	unwrapped = false

Member Typedef Documentation

CommandFn

using Slic3r::GUI::UVEditorCanvas::CommandFn = std::function<void(Command, float)>

IslandEditFn

using Slic3r::GUI::UVEditorCanvas::IslandEditFn

Initial value:

 
        std::function<void(int island, const Vec2f &offset_delta, float rotation_delta, float scale_factor, bool finished)>

IslandTransform

using Slic3r::GUI::UVEditorCanvas::IslandTransform = Eigen::Matrix<float, 2, 3>

PaneStateFn

using Slic3r::GUI::UVEditorCanvas::PaneStateFn = std::function<void(const PaneState &)>

StatusFn

using Slic3r::GUI::UVEditorCanvas::StatusFn = std::function<void(const wxString &)>

UVVertexEditFn

using Slic3r::GUI::UVEditorCanvas::UVVertexEditFn = std::function<void(const std::vector<std::pair<int, Vec2f>> &edits)>

Member Enumeration Documentation

Background

enum class Slic3r::GUI::UVEditorCanvas::Background

strong

Enumerator
Height
Checker
Distortion

{ Height, Checker, Distortion };

Command

enum class Slic3r::GUI::UVEditorCanvas::Command

strong

Enumerator
FrameAll
ToggleSnap
AverageScale
CutSelectedIsland
ProjectFromView
JoinSelected
UnjoinSelected
Unwrap
SetSeamAngle
SetConnectIslands
SetSelectMode
SetMarkSeams
SetSeamPath
ClearSeams
ClearUVEdits
SetBackground
PickTexture
PaneClosed
SelectionChanged

                       {
        FrameAll, ToggleSnap, AverageScale, CutSelectedIsland, ProjectFromView, JoinSelected, UnjoinSelected,
        Unwrap, SetSeamAngle, SetConnectIslands, SetSelectMode, SetMarkSeams, SetSeamPath, ClearSeams, ClearUVEdits,
        SetBackground, PickTexture, PaneClosed, SelectionChanged
    };

Gesture

enum class Slic3r::GUI::UVEditorCanvas::Gesture

strongprivate

Enumerator
None
Pan
MoveIsland
RotateIsland
RotateIslandModal
ScaleIslandModal
MoveVertex
MoveEdge

    {
        None,
        Pan,
        MoveIsland,
        RotateIsland,      // right-drag: rotation tracks the mouse, ends when the button is released
        RotateIslandModal, // 'R': rotation tracks the mouse until a click confirms or Esc cancels
        ScaleIslandModal,  // 'S': likewise, distance from the centre drives the scale
        MoveVertex,        // Vertex mode: drag one unwrapped vertex
        MoveEdge,          // Edge mode: drag both endpoints of one boundary edge
    };

SelectMode

enum class Slic3r::GUI::UVEditorCanvas::SelectMode

strong

Enumerator
Island
Vertex
Edge

{ Island, Vertex, Edge };

Constructor & Destructor Documentation

UVEditorCanvas()

Slic3r::GUI::UVEditorCanvas::UVEditorCanvas ( wxWindow * parent )

explicit

    : wxGLCanvas(parent, wxID_ANY, gl_attrib_list().data(), wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS)
{
    // The GL canvas paints its entire surface, so background erasing is unnecessary (and would
    // otherwise race with our own rendering) - same setup as OpenGLManager::create_wxglcanvas().
    SetBackgroundStyle(wxBG_STYLE_PAINT);
 
    // Shares the app's one real GL context (see class comment) rather than creating an
    // independent one - this is the same call View3D/Preview/AssembleView make in
    // GUI_Preview.cpp, and is what lets this canvas reuse wxGetApp().get_shader(...) and GLModel.
    m_context = wxGetApp().init_glcontext(*this);
 
    Bind(wxEVT_PAINT, &UVEditorCanvas::on_paint, this);
    Bind(wxEVT_SIZE, &UVEditorCanvas::on_size, this);
    Bind(wxEVT_LEFT_DOWN, &UVEditorCanvas::on_mouse, this);
    Bind(wxEVT_LEFT_UP, &UVEditorCanvas::on_mouse, this);
    Bind(wxEVT_RIGHT_DOWN, &UVEditorCanvas::on_mouse, this);
    Bind(wxEVT_RIGHT_UP, &UVEditorCanvas::on_mouse, this);
    Bind(wxEVT_MIDDLE_DOWN, &UVEditorCanvas::on_mouse, this);
    Bind(wxEVT_MIDDLE_UP, &UVEditorCanvas::on_mouse, this);
    Bind(wxEVT_MOTION, &UVEditorCanvas::on_mouse, this);
    Bind(wxEVT_MOUSE_CAPTURE_LOST, &UVEditorCanvas::on_capture_lost, this);
    Bind(wxEVT_MOUSEWHEEL, &UVEditorCanvas::on_mouse, this);
    Bind(wxEVT_LEAVE_WINDOW, &UVEditorCanvas::on_leave, this);
    Bind(wxEVT_KEY_DOWN, &UVEditorCanvas::on_key, this);
    Bind(wxEVT_ERASE_BACKGROUND, &UVEditorCanvas::on_erase_background, this);
}

References m_context, on_capture_lost(), on_erase_background(), on_key(), on_leave(), on_mouse(), on_paint(), and on_size().

Here is the call graph for this function:

Member Function Documentation

cancel_gesture()

void Slic3r::GUI::UVEditorCanvas::cancel_gesture ( )

private

{
    // Undo what the gesture already applied live, as the Esc path does, and commit nothing.
    if (m_on_island_edit) {
        if (m_gesture == Gesture::RotateIslandModal && m_rot_applied_deg != 0.f)
            m_on_island_edit(m_selected_island, Vec2f::Zero(), -m_rot_applied_deg, 1.f, false);
        if (m_gesture == Gesture::ScaleIslandModal && m_modal_scale_accum != 1.f)
            m_on_island_edit(m_selected_island, Vec2f::Zero(), 0.f, 1.f / m_modal_scale_accum, false);
    }
 
    m_gesture           = Gesture::None;
    m_rot_raw_deg       = 0.f;
    m_rot_applied_deg   = 0.f;
    m_modal_scale_accum = 1.f;
    m_vertex_edit_moved = false;
}

References m_gesture, m_modal_scale_accum, m_on_island_edit, m_rot_applied_deg, m_rot_raw_deg, m_selected_island, m_vertex_edit_moved, None, RotateIslandModal, and ScaleIslandModal.

Referenced by on_capture_lost().

Here is the caller graph for this function:

content_bounds()

void Slic3r::GUI::UVEditorCanvas::content_bounds ( Vec2f & min_uv, Vec2f & max_uv ) const

private

{
    // Always include the texture's first tile, so an unwrap that happens to be tiny, or absent,
    // still leaves something sensibly framed on screen.
    min_uv = Vec2f(0.f, 0.f);
    max_uv = Vec2f(1.f, 1.f);
    for (size_t i = 0; i < m_islands.uvs.size(); ++i) {
        const Vec2f uv = island_uv(i);
        min_uv = min_uv.cwiseMin(uv);
        max_uv = max_uv.cwiseMax(uv);
    }
}

References island_uv(), and m_islands.

Referenced by framed_bounds().

Here is the call graph for this function:

Here is the caller graph for this function:

drop_mouse()

void Slic3r::GUI::UVEditorCanvas::drop_mouse ( )

private

{
    if (HasCapture())
        ReleaseMouse();
}

Referenced by end_gesture(), and on_mouse().

Here is the caller graph for this function:

edge_at()

std::pair< int, int > Slic3r::GUI::UVEditorCanvas::edge_at ( const Vec2f & uv ) const

private

{
    const wxSize size      = GetSize();
    const float  uv_per_px = 2.f * m_zoom / float(std::max(1, std::min(size.GetWidth(), size.GetHeight())));
    const float  threshold = SNAP_PIXELS * uv_per_px;
 
    // Point-to-segment distance in texture-UV space, against the island outlines (the edges the pane
    // exists to show). Interior edges are left alone: the boundary is what a user reshapes.
    const auto seg_dist_sq = [](const Vec2f &p, const Vec2f &a, const Vec2f &b) {
        const Vec2f 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)).squaredNorm();
    };
    std::pair<int, int> best{ -1, -1 };
    float               best_d = threshold * threshold;
    for (const auto &[a, b] : m_islands.boundary_edges) {
        if (a < 0 || b < 0 || size_t(a) >= m_islands.uvs.size() || size_t(b) >= m_islands.uvs.size())
            continue;
        const float d = seg_dist_sq(uv, island_uv(size_t(a)), island_uv(size_t(b)));
        if (d < best_d) {
            best_d = d;
            best   = { a, b };
        }
    }
    return best;
}

References Slic3r::dot(), island_uv(), Slic3r::l2(), m_islands, and m_zoom.

Referenced by on_mouse(), and update_hover().

Here is the call graph for this function:

Here is the caller graph for this function:

end_gesture()

void Slic3r::GUI::UVEditorCanvas::end_gesture ( )

private

{
    const bool was_editing = m_gesture == Gesture::MoveIsland || m_gesture == Gesture::RotateIsland ||
                             m_gesture == Gesture::RotateIslandModal || m_gesture == Gesture::ScaleIslandModal;
 
    // Stick to a neighbour at the end of a move, rather than magnetically fighting the cursor
    // throughout it - a snap that keeps re-applying mid-drag is very hard to pull *out* of.
    if (m_gesture == Gesture::MoveIsland && m_on_island_edit) {
        const Vec2f correction = snap_correction(m_selected_island);
        if (!correction.isZero())
            m_on_island_edit(m_selected_island, uv_delta_to_unwrap(correction), 0.f, 1.f, false);
    }
 
    if (was_editing && m_on_island_edit)
        m_on_island_edit(m_selected_island, Vec2f::Zero(), 0.f, 1.f, /* finished */ true);
 
    // Commit a vertex/edge edit once, on release: hand the owner the affected unwrapped vertices and
    // their new raw-unwrap coordinates so it can store the overrides and re-solve the bake preview.
    if ((m_gesture == Gesture::MoveVertex || m_gesture == Gesture::MoveEdge) && m_vertex_edit_moved &&
        m_on_vertex_edit) {
        std::vector<std::pair<int, Vec2f>> edits;
        const auto add = [&](int v) {
            if (v >= 0 && size_t(v) < m_islands.uvs.size())
                edits.emplace_back(v, m_islands.uvs[size_t(v)]);
        };
        // Commit every element of the multi-selection, not just the primary, so a group drag stores all
        // the moved vertices' overrides. Falls back to the primary if the selection is somehow empty.
        if (m_gesture == Gesture::MoveVertex) {
            if (m_sel_vertices.empty())
                add(m_active_vertex);
            else
                for (const int v : m_sel_vertices)
                    add(v);
        } else {
            const std::vector<int> endpoints = selected_edge_endpoints();
            if (endpoints.empty()) {
                add(m_active_edge.first);
                add(m_active_edge.second);
            } else
                for (const int v : endpoints)
                    add(v);
        }
        if (!edits.empty())
            m_on_vertex_edit(edits);
    }
 
    m_gesture           = Gesture::None;
    m_rot_raw_deg       = 0.f;
    m_rot_applied_deg   = 0.f;
    m_modal_scale_accum = 1.f;
    drop_mouse();
}

References drop_mouse(), m_active_edge, m_active_vertex, m_gesture, m_islands, m_modal_scale_accum, m_on_island_edit, m_on_vertex_edit, m_rot_applied_deg, m_rot_raw_deg, m_sel_vertices, m_selected_island, m_vertex_edit_moved, MoveEdge, MoveIsland, MoveVertex, None, RotateIsland, RotateIslandModal, ScaleIslandModal, selected_edge_endpoints(), snap_correction(), and uv_delta_to_unwrap().

Referenced by on_key(), and on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

fit_view_to_content()

void Slic3r::GUI::UVEditorCanvas::fit_view_to_content ( )

private

{
    Vec2f min_uv, max_uv;
    framed_bounds(min_uv, max_uv);
 
    const wxSize size   = GetSize();
    const float  aspect = float(std::max(1, size.GetWidth())) / float(std::max(1, size.GetHeight()));
    const Vec2f  half   = 0.5f * (max_uv - min_uv);
 
    m_pan = 0.5f * (min_uv + max_uv);
    // m_zoom is the half-extent shown across the *shorter* pane edge (see view_half_extents()), so
    // each axis' required half-extent has to be converted back into that unit before the larger of
    // the two is taken. Sizing off the bigger axis alone, as this did, ignores the pane's shape and
    // zooms out further than either axis needs on anything but a square pane. The 1.1 leaves a
    // margin so the outermost island edge is not flush against the frame.
    m_zoom = std::max(1.1f * std::max(half.x() / std::max(aspect, 1.f), half.y() * std::min(aspect, 1.f)),
                      0.05f);
    m_needs_fit = false;
}

References framed_bounds(), m_needs_fit, m_pan, and m_zoom.

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

framed_bounds()

void Slic3r::GUI::UVEditorCanvas::framed_bounds ( Vec2f & min_uv, Vec2f & max_uv ) const

private

{
    content_bounds(min_uv, max_uv);
    // With tiling on, the backdrop is snapped out to whole tiles, so it is bigger than the raw
    // bounds - and by a different amount on each side. Framing the raw bounds therefore left that
    // backdrop visibly off-centre: hanging past one edge of the pane with dead space against the
    // other. Frame what is drawn instead. (Tiling off draws only the first tile, which the bounds
    // already contain, so there is nothing to snap.)
    if (m_tile_enabled) {
        min_uv = Vec2f(std::floor(min_uv.x()), std::floor(min_uv.y()));
        max_uv = Vec2f(std::ceil(max_uv.x()), std::ceil(max_uv.y()));
    }
}

References content_bounds(), and m_tile_enabled.

Referenced by fit_view_to_content(), and rebuild_background_quad().

Here is the call graph for this function:

Here is the caller graph for this function:

grab_mouse()

void Slic3r::GUI::UVEditorCanvas::grab_mouse ( )

private

{
    if (!HasCapture())
        CaptureMouse();
}

Referenced by on_mouse().

Here is the caller graph for this function:

has_islands()

bool Slic3r::GUI::UVEditorCanvas::has_islands ( ) const

inline

{ return m_islands.island_count > 0 && !m_islands.indices.empty(); }

References m_islands.

Referenced by render(), update_hover(), and update_status().

Here is the caller graph for this function:

invalidate_gl()

void Slic3r::GUI::UVEditorCanvas::invalidate_gl ( )

inline

    {
        m_gl_reset_pending = true;
        Refresh();
    }

References m_gl_reset_pending.

is_edge_selected()

bool Slic3r::GUI::UVEditorCanvas::is_edge_selected ( const std::pair< int, int > & e ) const

inlineprivate

    {
        return std::find(m_sel_edges.begin(), m_sel_edges.end(), e) != m_sel_edges.end();
    }

References m_sel_edges.

Referenced by on_mouse(), and render().

Here is the caller graph for this function:

is_selected()

bool Slic3r::GUI::UVEditorCanvas::is_selected ( int island ) const

inlineprivate

    {
        return std::find(m_selection.begin(), m_selection.end(), island) != m_selection.end();
    }

References m_selection.

Referenced by island_at(), on_mouse(), and render().

Here is the caller graph for this function:

is_vertex_selected()

bool Slic3r::GUI::UVEditorCanvas::is_vertex_selected ( int v ) const

inlineprivate

    {
        return std::find(m_sel_vertices.begin(), m_sel_vertices.end(), v) != m_sel_vertices.end();
    }

References m_sel_vertices.

Referenced by on_mouse(), and render().

Here is the caller graph for this function:

island_at()

int Slic3r::GUI::UVEditorCanvas::island_at ( const Vec2f & uv ) const

private

{
    int found = -1;
    for (int island = 0; island < int(m_island_tris.size()); ++island) {
        // The raw bounds through the island's affine: the box of the four transformed corners contains the island.
        const auto &[lo, hi] = m_island_raw_bounds[size_t(island)];
        if (lo.x() > hi.x())
            continue;
        const IslandTransform m = size_t(island) < m_transforms.size() ? m_transforms[size_t(island)] :
                                                                         IslandTransform(IslandTransform::Identity());
        Vec2f bmin = Vec2f::Constant(std::numeric_limits<float>::max()), bmax = -bmin;
        for (const Vec2f &corner : { lo, hi, Vec2f(lo.x(), hi.y()), Vec2f(hi.x(), lo.y()) }) {
            const Vec2f p = m.block<2, 2>(0, 0) * corner + m.col(2);
            bmin          = bmin.cwiseMin(p);
            bmax          = bmax.cwiseMax(p);
        }
        if (uv.x() < bmin.x() || uv.y() < bmin.y() || uv.x() > bmax.x() || uv.y() > bmax.y())
            continue;
 
        for (const int t : m_island_tris[size_t(island)]) {
            const Vec3i32 &tri = m_islands.indices[size_t(t)];
            if (!point_in_triangle(uv, island_uv(size_t(tri[0])), island_uv(size_t(tri[1])), island_uv(size_t(tri[2]))))
                continue;
            // Islands are allowed to overlap, so a point can be inside several. Keep whichever is already
            // selected - otherwise a drag of a partly-covered island would be stolen mid-gesture by the
            // one on top of it.
            if (is_selected(island))
                return island;
            found = island;
            break;
        }
    }
    return found;
}

References is_selected(), island_uv(), m_island_raw_bounds, m_island_tris, m_islands, and m_transforms.

Referenced by on_mouse(), and update_hover().

Here is the call graph for this function:

Here is the caller graph for this function:

island_centroid()

Vec2f Slic3r::GUI::UVEditorCanvas::island_centroid ( int island ) const

private

{
    Vec2f sum   = Vec2f::Zero();
    int   count = 0;
    for (size_t i = 0; i < m_islands.uvs.size(); ++i)
        if (m_islands.vertex_island[i] == island) {
            sum += island_uv(i);
            ++count;
        }
    return (count > 0) ? Vec2f(sum / float(count)) : Vec2f::Zero();
}

References count, island_uv(), and m_islands.

Referenced by on_key(), on_mouse(), and rebuild_rotation_dial().

Here is the call graph for this function:

Here is the caller graph for this function:

island_rotation_deg()

float Slic3r::GUI::UVEditorCanvas::island_rotation_deg ( int island ) const

private

{
    // The rotation baked into the island's affine, in the same y-down UV convention the gesture uses.
    // First column is scale*(cos, sin); its angle is the island's on-screen orientation.
    if (island < 0 || size_t(island) >= m_transforms.size())
        return 0.f;
    const IslandTransform &m = m_transforms[size_t(island)];
    return std::atan2(m(1, 0), m(0, 0)) * 180.f / float(M_PI);
}

References M_PI, and m_transforms.

Referenced by on_key(), and on_mouse().

Here is the caller graph for this function:

island_uv()

Vec2f Slic3r::GUI::UVEditorCanvas::island_uv ( size_t vertex ) const

private

{
    const Vec2f &raw = m_islands.uvs[vertex];
    const int    island = m_islands.vertex_island[vertex];
    if (island < 0 || size_t(island) >= m_transforms.size())
        return raw;
    const IslandTransform &m = m_transforms[size_t(island)];
    return m.block<2, 2>(0, 0) * raw + m.col(2);
}

References m_islands, and m_transforms.

Referenced by content_bounds(), edge_at(), island_at(), island_centroid(), render(), snap_correction(), and vertex_at().

Here is the caller graph for this function:

move_vertex_raw()

void Slic3r::GUI::UVEditorCanvas::move_vertex_raw ( int unwrapped_vertex, const Vec2f & delta_uv )

private

{
    if (v < 0 || size_t(v) >= m_islands.uvs.size())
        return;
    const int island = m_islands.vertex_island[size_t(v)];
    // The gesture happens in texture-UV space; the stored coordinate is the raw unwrap. Undo the
    // island's own linear map (which includes the layer's tiling scale + rotation) to get there.
    Eigen::Matrix2f lin = Eigen::Matrix2f::Identity();
    if (island >= 0 && size_t(island) < m_transforms.size())
        lin = m_transforms[size_t(island)].block<2, 2>(0, 0);
    const float det = lin.determinant();
    const Vec2f raw_delta = (std::abs(det) > 1e-12f) ? Vec2f(lin.inverse() * delta_uv) : delta_uv;
    m_islands.uvs[size_t(v)] += raw_delta;
    if (island >= 0 && size_t(island) < m_island_raw_bounds.size()) { // keep the pick box around the moved vertex
        auto &[lo, hi] = m_island_raw_bounds[size_t(island)];
        lo = lo.cwiseMin(m_islands.uvs[size_t(v)]);
        hi = hi.cwiseMax(m_islands.uvs[size_t(v)]);
    }
    m_mesh_dirty = true; // the edited raw uv is redrawn from rebuild_island_models() next frame
}

References m_island_raw_bounds, m_islands, m_mesh_dirty, and m_transforms.

Referenced by on_mouse().

Here is the caller graph for this function:

on_capture_lost()

void Slic3r::GUI::UVEditorCanvas::on_capture_lost ( wxMouseCaptureLostEvent & evt )

private

{
    cancel_gesture();
    Refresh();
}

References cancel_gesture().

Referenced by UVEditorCanvas().

Here is the call graph for this function:

Here is the caller graph for this function:

on_erase_background()

void Slic3r::GUI::UVEditorCanvas::on_erase_background ( wxEraseEvent & evt )

inlineprivate

{} // required to avoid flicker on MSW, deliberately a no-op

Referenced by UVEditorCanvas().

Here is the caller graph for this function:

on_key()

void Slic3r::GUI::UVEditorCanvas::on_key ( wxKeyEvent & evt )

private

{
    const int key = evt.GetKeyCode();
 
    // Undo/redo while the pane has focus. Island edits already take a Plater snapshot per gesture (see
    // GLGizmoTextureDisplacement::on_island_edited), so this just drives the same global history; the
    // gizmo re-pushes the restored island transforms into the canvas on the reload that follows.
    if (evt.ControlDown() && (key == 'Z' || key == 'z')) {
        if (evt.ShiftDown()) wxGetApp().plater()->redo();
        else                 wxGetApp().plater()->undo();
        return;
    }
    if (evt.ControlDown() && (key == 'Y' || key == 'y')) {
        wxGetApp().plater()->redo();
        return;
    }
 
    if (m_gesture == Gesture::RotateIslandModal || m_gesture == Gesture::ScaleIslandModal) {
        if (key == WXK_ESCAPE) {
            // Put the island back exactly where the modal gesture found it, then finish.
            if (m_on_island_edit) {
                if (m_gesture == Gesture::RotateIslandModal && m_rot_applied_deg != 0.f)
                    m_on_island_edit(m_selected_island, Vec2f::Zero(), -m_rot_applied_deg, 1.f, false);
                if (m_gesture == Gesture::ScaleIslandModal && m_modal_scale_accum != 1.f)
                    m_on_island_edit(m_selected_island, Vec2f::Zero(), 0.f, 1.f / m_modal_scale_accum, false);
            }
            end_gesture();
            Refresh();
            return;
        }
        if (key == WXK_RETURN || key == WXK_NUMPAD_ENTER) {
            end_gesture();
            Refresh();
            return;
        }
    }
 
    // Frame everything. The unwrap is packed in mm and then divided by the layer's tile size, so it
    // can easily sit tens of tiles away from the texture's first one - panning back by hand from
    // there is hopeless, and without this there would be no way to reach reset_view() at all.
    if (key == WXK_HOME || key == 'F' || key == 'f') {
        reset_view();
        return;
    }
 
    // Blender's modal transforms: R / S, then the transform follows the mouse until it is confirmed
    // with a click or Enter, or abandoned with Esc.
    if (m_selected_island >= 0 && m_select_mode == SelectMode::Island && m_gesture == Gesture::None &&
        (key == 'R' || key == 'r' || key == 'S' || key == 's')) {
        const Vec2f uv     = screen_to_uv(ScreenToClient(wxGetMousePosition()));
        const Vec2f centre = island_centroid(m_selected_island);
        const Vec2f rel    = uv - centre;
        if (key == 'R' || key == 'r') {
            m_gesture            = Gesture::RotateIslandModal;
            m_rot_raw_deg        = 0.f;
            m_rot_applied_deg    = 0.f;
            m_rot_base_deg       = island_rotation_deg(m_selected_island);
            m_rot_display_deg    = m_rot_base_deg;
            m_gesture_last_angle = std::atan2(rel.y(), rel.x());
        } else {
            m_gesture           = Gesture::ScaleIslandModal;
            m_modal_scale_accum = 1.f;
            m_gesture_last_dist = std::max(rel.norm(), 1e-6f);
        }
        return;
    }
 
    evt.Skip();
}

References end_gesture(), Island, island_centroid(), island_rotation_deg(), m_gesture, m_gesture_last_angle, m_gesture_last_dist, m_modal_scale_accum, m_on_island_edit, m_rot_applied_deg, m_rot_base_deg, m_rot_display_deg, m_rot_raw_deg, m_select_mode, m_selected_island, None, reset_view(), RotateIslandModal, ScaleIslandModal, and screen_to_uv().

Referenced by UVEditorCanvas().

Here is the call graph for this function:

Here is the caller graph for this function:

on_leave()

void Slic3r::GUI::UVEditorCanvas::on_leave ( wxMouseEvent & evt )

private

{
    evt.Skip();
    if (m_cursor_inside) {
        m_cursor_inside = false;
        // The +/- hint and the hover highlight were following the cursor; drop them now the pointer is gone.
        if (m_gesture == Gesture::None) {
            m_hover_island = m_hover_vertex = -1;
            m_hover_edge   = { -1, -1 };
        }
        Refresh();
    }
}

References m_cursor_inside, m_gesture, m_hover_edge, m_hover_island, m_hover_vertex, None, and Slic3r::GUI::wxMouseEvent.

Referenced by UVEditorCanvas().

Here is the caller graph for this function:

on_mouse()

void Slic3r::GUI::UVEditorCanvas::on_mouse ( wxMouseEvent & evt )

private

{
    const wxEventType type = evt.GetEventType();
    const wxPoint     pos  = evt.GetPosition();
 
    // Track the pointer so the +/- add-remove hint can be drawn next to it in Vertex/Edge mode.
    m_cursor_px     = pos;
    m_cursor_inside = true;
    if (type == wxEVT_MOTION && m_gesture == Gesture::None) {
        update_hover(pos);
        if (m_select_mode != SelectMode::Island)
            Refresh(); // animate the hint (and its +/- flip) as the pointer/modifiers move
    }
 
    // Key events (R/S/Home) only arrive if this canvas has focus, and clicking it is the natural way
    // to ask for it - the pane is not in the tab order.
    if (type == wxEVT_LEFT_DOWN || type == wxEVT_RIGHT_DOWN || type == wxEVT_MIDDLE_DOWN)
        SetFocus();
 
    // A modal R/S is confirmed by any click, exactly as in Blender.
    if ((m_gesture == Gesture::RotateIslandModal || m_gesture == Gesture::ScaleIslandModal) &&
        (type == wxEVT_LEFT_DOWN || type == wxEVT_RIGHT_DOWN)) {
        end_gesture();
        Refresh();
        return;
    }
 
    if (type == wxEVT_LEFT_DOWN) {
        const Vec2f uv    = screen_to_uv(pos);
        m_drag_last_px    = pos;
        m_gesture_last_uv = uv;
        if (m_select_mode == SelectMode::Vertex) {
            const int hit       = vertex_at(uv);
            m_active_edge       = { -1, -1 };
            m_vertex_edit_moved = false;
            // Same Shift-adds / Ctrl-toggles / plain-replaces rules as island selection, so a group of
            // vertices can be picked and dragged together.
            if (hit >= 0) {
                if (evt.ShiftDown()) {
                    if (!is_vertex_selected(hit))
                        m_sel_vertices.push_back(hit);
                } else if (evt.ControlDown()) {
                    if (auto it = std::find(m_sel_vertices.begin(), m_sel_vertices.end(), hit); it != m_sel_vertices.end())
                        m_sel_vertices.erase(it);
                    else
                        m_sel_vertices.push_back(hit);
                } else if (!is_vertex_selected(hit)) {
                    m_sel_vertices.assign(1, hit);
                }
            } else if (!evt.ShiftDown() && !evt.ControlDown()) {
                m_sel_vertices.clear();
            }
            // Primary = the clicked vertex only if it is (still) selected; a Ctrl-deselect just toggles.
            m_active_vertex = (hit >= 0 && is_vertex_selected(hit)) ? hit : -1;
            m_gesture       = (m_active_vertex >= 0) ? Gesture::MoveVertex : Gesture::Pan;
        } else if (m_select_mode == SelectMode::Edge) {
            const std::pair<int, int> hit = edge_at(uv);
            m_active_vertex     = -1;
            m_vertex_edit_moved = false;
            if (hit.first >= 0) {
                if (evt.ShiftDown()) {
                    if (!is_edge_selected(hit))
                        m_sel_edges.push_back(hit);
                } else if (evt.ControlDown()) {
                    if (auto it = std::find(m_sel_edges.begin(), m_sel_edges.end(), hit); it != m_sel_edges.end())
                        m_sel_edges.erase(it);
                    else
                        m_sel_edges.push_back(hit);
                } else if (!is_edge_selected(hit)) {
                    m_sel_edges.assign(1, hit);
                }
            } else if (!evt.ShiftDown() && !evt.ControlDown()) {
                m_sel_edges.clear();
            }
            m_active_edge = (hit.first >= 0 && is_edge_selected(hit)) ? hit : std::pair<int, int>{ -1, -1 };
            m_gesture     = (m_active_edge.first >= 0) ? Gesture::MoveEdge : Gesture::Pan;
        } else {
            const std::vector<int> selection_before = m_selection;
            const int              hit              = island_at(uv);
            if (hit >= 0) {
                if (evt.ShiftDown()) {
                    // Shift adds to the selection (and makes the clicked one the new primary).
                    if (!is_selected(hit))
                        m_selection.push_back(hit);
                    m_selected_island = hit;
                } else if (evt.ControlDown()) {
                    // Ctrl toggles: clicking a selected island removes it (the requested "deselect"),
                    // clicking an unselected one adds it.
                    if (auto it = std::find(m_selection.begin(), m_selection.end(), hit); it != m_selection.end()) {
                        m_selection.erase(it);
                        m_selected_island = m_selection.empty() ? -1 : m_selection.back();
                    } else {
                        m_selection.push_back(hit);
                        m_selected_island = hit;
                    }
                } else {
                    // Plain click: keep the whole selection if the clicked island is already part of it (so
                    // a drag moves the group), otherwise collapse to just this one.
                    if (!is_selected(hit))
                        m_selection.assign(1, hit);
                    m_selected_island = hit;
                }
            } else if (!evt.ShiftDown() && !evt.ControlDown()) {
                // Clicking empty space with no modifier clears the selection and pans.
                m_selection.clear();
                m_selected_island = -1;
            }
            m_gesture = (m_selected_island >= 0) ? Gesture::MoveIsland : Gesture::Pan;
            // The owner shows the selection on the model and would not hear of this click otherwise in time: a
            // click that clears the selection starts no gesture, and one that sets it reports only on release.
            if (m_selection != selection_before)
                run_command(Command::SelectionChanged);
        }
        grab_mouse();
        Refresh();
    } else if (type == wxEVT_RIGHT_DOWN && m_selected_island >= 0 && m_select_mode == SelectMode::Island) {
        const Vec2f rel      = screen_to_uv(pos) - island_centroid(m_selected_island);
        m_gesture            = Gesture::RotateIsland;
        m_rot_raw_deg        = 0.f;
        m_rot_applied_deg    = 0.f;
        m_rot_base_deg       = island_rotation_deg(m_selected_island);
        m_rot_display_deg    = m_rot_base_deg;
        m_gesture_last_angle = std::atan2(rel.y(), rel.x());
        grab_mouse();
    } else if (type == wxEVT_MIDDLE_DOWN) {
        m_gesture      = Gesture::Pan;
        m_drag_last_px = pos;
        grab_mouse();
    } else if (type == wxEVT_LEFT_UP || type == wxEVT_RIGHT_UP || type == wxEVT_MIDDLE_UP) {
        // The drag is over either way. A modal R/S keeps running until a click confirms it, but it
        // tracks the pointer over this canvas and needs no capture to do so, so the capture goes back
        // here rather than waiting for that click - which may never come.
        drop_mouse();
        if (m_gesture != Gesture::RotateIslandModal && m_gesture != Gesture::ScaleIslandModal) {
            end_gesture();
            Refresh();
        }
    } else if (type == wxEVT_MOTION) {
        switch (m_gesture) {
        case Gesture::Pan: {
            const wxSize size  = GetSize();
            const float  scale = 2.f * m_zoom / float(std::max(1, std::min(size.GetWidth(), size.GetHeight())));
            // Both axes point the same way on screen as in UV space (v runs down), so dragging the
            // content along with the cursor is a subtraction on both.
            m_pan.x() -= float(pos.x - m_drag_last_px.x) * scale;
            m_pan.y() -= float(pos.y - m_drag_last_px.y) * scale;
            m_drag_last_px = pos;
            Refresh();
            break;
        }
        case Gesture::MoveIsland: {
            const Vec2f uv = screen_to_uv(pos);
            if (m_on_island_edit)
                m_on_island_edit(m_selected_island, uv_delta_to_unwrap(uv - m_gesture_last_uv), 0.f, 1.f, false);
            m_gesture_last_uv = uv;
            Refresh();
            break;
        }
        case Gesture::MoveVertex: {
            const Vec2f uv    = screen_to_uv(pos);
            const Vec2f delta = uv - m_gesture_last_uv;
            // Move the whole selection by the same uv-space delta (each vertex converts it through its
            // own island transform in move_vertex_raw). Falls back to the primary if none is selected.
            if (m_sel_vertices.empty())
                move_vertex_raw(m_active_vertex, delta);
            else
                for (const int v : m_sel_vertices)
                    move_vertex_raw(v, delta);
            m_gesture_last_uv   = uv;
            m_vertex_edit_moved = true;
            Refresh();
            break;
        }
        case Gesture::MoveEdge: {
            const Vec2f uv    = screen_to_uv(pos);
            const Vec2f delta = uv - m_gesture_last_uv;
            // Move every unique endpoint of every selected edge once. Falls back to the primary edge.
            const std::vector<int> endpoints = selected_edge_endpoints();
            if (endpoints.empty()) {
                move_vertex_raw(m_active_edge.first, delta);
                move_vertex_raw(m_active_edge.second, delta);
            } else
                for (const int v : endpoints)
                    move_vertex_raw(v, delta);
            m_gesture_last_uv   = uv;
            m_vertex_edit_moved = true;
            Refresh();
            break;
        }
        case Gesture::RotateIsland:
        case Gesture::RotateIslandModal: {
            const Vec2f rel   = screen_to_uv(pos) - island_centroid(m_selected_island);
            const float angle = std::atan2(rel.y(), rel.x());
            // Accumulate the raw mouse rotation incrementally so it survives crossing +/-180 degrees.
            m_rot_raw_deg += angle_delta(m_gesture_last_angle, angle) * 180.f / float(M_PI);
            m_gesture_last_angle = angle;
 
            // With Shift, quantise to *global* 15-degree marks (0/15/30...), i.e. snap the island's
            // absolute on-screen orientation, not 15 degrees relative to wherever it started (#10) -
            // snapping the target rather than each delta is what keeps it from juddering on a step.
            constexpr float STEP       = 15.f;
            const float     absolute   = m_rot_base_deg + m_rot_raw_deg;
            const float     target_abs = evt.ShiftDown() ? std::round(absolute / STEP) * STEP : absolute;
            const float     deg        = target_abs - (m_rot_base_deg + m_rot_applied_deg);
            if (m_on_island_edit && deg != 0.f)
                m_on_island_edit(m_selected_island, Vec2f::Zero(), deg, 1.f, false);
            m_rot_applied_deg = target_abs - m_rot_base_deg;
            m_rot_display_deg = target_abs;
            Refresh();
            break;
        }
        case Gesture::ScaleIslandModal: {
            const Vec2f rel  = screen_to_uv(pos) - island_centroid(m_selected_island);
            const float dist = std::max(rel.norm(), 1e-6f);
            const float factor = dist / m_gesture_last_dist;
            if (m_on_island_edit && factor != 1.f)
                m_on_island_edit(m_selected_island, Vec2f::Zero(), 0.f, factor, false);
            m_modal_scale_accum *= factor;
            m_gesture_last_dist = dist;
            Refresh();
            break;
        }
        default: break;
        }
    } else if (type == wxEVT_MOUSEWHEEL) {
        // Zoom about the cursor, not the view centre - otherwise zooming in on something off to the
        // side walks it straight out of the frame.
        const Vec2f before = screen_to_uv(pos);
        const float factor = std::pow(0.9f, float(evt.GetWheelRotation()) / float(evt.GetWheelDelta()));
        m_zoom             = std::clamp(m_zoom * factor, 0.001f, 5000.f);
        const Vec2f after  = screen_to_uv(pos);
        m_pan += before - after;
        if (m_gesture == Gesture::None)
            update_hover(pos);
        Refresh();
    }
}

References Slic3r::angle(), Slic3r::Geometry::dist(), drop_mouse(), Edge, edge_at(), end_gesture(), grab_mouse(), is_edge_selected(), is_selected(), is_vertex_selected(), Island, island_at(), island_centroid(), island_rotation_deg(), m_active_edge, m_active_vertex, m_cursor_inside, m_cursor_px, m_drag_last_px, m_gesture, m_gesture_last_angle, m_gesture_last_dist, m_gesture_last_uv, m_modal_scale_accum, m_on_island_edit, m_pan, M_PI, m_rot_applied_deg, m_rot_base_deg, m_rot_display_deg, m_rot_raw_deg, m_sel_edges, m_sel_vertices, m_select_mode, m_selected_island, m_selection, m_vertex_edit_moved, m_zoom, move_vertex_raw(), MoveEdge, MoveIsland, MoveVertex, None, Pan, RotateIsland, RotateIslandModal, run_command(), scale(), ScaleIslandModal, screen_to_uv(), selected_edge_endpoints(), SelectionChanged, update_hover(), uv_delta_to_unwrap(), Vertex, vertex_at(), and Slic3r::GUI::wxMouseEvent.

Referenced by UVEditorCanvas().

Here is the call graph for this function:

Here is the caller graph for this function:

on_paint()

void Slic3r::GUI::UVEditorCanvas::on_paint ( wxPaintEvent & evt )

private

{
    wxPaintDC dc(this);
    render();
}

References render().

Referenced by UVEditorCanvas().

Here is the call graph for this function:

Here is the caller graph for this function:

on_size()

void Slic3r::GUI::UVEditorCanvas::on_size ( wxSizeEvent & evt )

private

{
    evt.Skip();
    // Refresh() alone only *schedules* a repaint, which Windows can coalesce/delay until a live
    // resize drag ends, leaving stale wrong-aspect-ratio content on screen throughout the drag.
    // Update() flushes it immediately - still through the normal paint path (unlike calling
    // render() directly), which matters because this canvas shares the app's one GL context with
    // the 3D view and must not hijack it outside its own paint.
    // Not while a 3D canvas frame is in progress, though: wxGTK delivers this size event synchronously
    // when the texture displacement gizmo relays out the pane from its ImGui panel, i.e. from inside
    // that frame, and flushing the paint there would take the shared context away from it. The Refresh()
    // then runs the paint once the frame is over.
    Refresh();
    if (!GLCanvas3D::is_frame_in_progress())
        Update();
}

References Slic3r::GUI::GLCanvas3D::is_frame_in_progress().

Referenced by UVEditorCanvas().

Here is the call graph for this function:

Here is the caller graph for this function:

pane_state()

const PaneState & Slic3r::GUI::UVEditorCanvas::pane_state ( ) const

inline

{ return m_pane_state; }

References m_pane_state.

rebuild_background_quad()

void Slic3r::GUI::UVEditorCanvas::rebuild_background_quad ( )

private

{
    m_background_glmodel.reset();
    m_background_quad_dirty = false;
    if (m_background_width <= 0 || m_background_height <= 0)
        return;
 
    Vec2f lo, hi;
    if (m_tile_enabled) {
        // Whole tiles, so the backdrop's edge lands on a tile boundary instead of slicing a brick in
        // half. framed_bounds() applies exactly this, and the view is framed on its result - the two
        // must not drift apart or the backdrop stops being centred in the pane.
        framed_bounds(lo, hi);
    } else {
        // Tiling off: the sampler reads 0 outside the first tile and nothing else exists, so the
        // backdrop is exactly that one tile (GL_CLAMP_TO_BORDER in render() gives it the same
        // black surround, rather than smearing the edge texels outward).
        lo = Vec2f(0.f, 0.f);
        hi = Vec2f(1.f, 1.f);
    }
 
    GLModel::Geometry init_data;
    init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3T2 };
    init_data.reserve_vertices(4);
    init_data.reserve_indices(6);
    // Texcoord == position: the height sampling maps one whole texture onto each unit square of uv
    // (see DecodedHeightTexture::sample()), so uv *is* the texture coordinate. That also puts the
    // texture's first pixel row at v = 0, exactly where sample() reads it.
    init_data.add_vertex(Vec3f(lo.x(), lo.y(), 0.f), Vec2f(lo.x(), lo.y()));
    init_data.add_vertex(Vec3f(hi.x(), lo.y(), 0.f), Vec2f(hi.x(), lo.y()));
    init_data.add_vertex(Vec3f(hi.x(), hi.y(), 0.f), Vec2f(hi.x(), hi.y()));
    init_data.add_vertex(Vec3f(lo.x(), hi.y(), 0.f), Vec2f(lo.x(), hi.y()));
    init_data.add_triangle(0, 1, 2);
    init_data.add_triangle(0, 2, 3);
    m_background_glmodel.init_from(std::move(init_data));
}

References Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::format, framed_bounds(), m_background_glmodel, m_background_height, m_background_quad_dirty, m_background_width, m_tile_enabled, Slic3r::GUI::GLModel::Geometry::P3T2, Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), and Slic3r::GUI::GLModel::Geometry::Triangles.

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

rebuild_background_texture()

void Slic3r::GUI::UVEditorCanvas::rebuild_background_texture ( )

private

{
    m_background_texture.reset();
    m_background_dirty = false;
    if (m_background_width > 0 && m_background_height > 0)
        m_background_texture.load_from_raw_data(m_background_pixels, (unsigned int) m_background_width,
                                                 (unsigned int) m_background_height, false);
    // The quad's extent doesn't depend on the pixels, but it does have to exist alongside them.
    m_background_quad_dirty = true;
}

References m_background_dirty, m_background_height, m_background_pixels, m_background_quad_dirty, m_background_texture, and m_background_width.

Referenced by render().

Here is the caller graph for this function:

rebuild_grid()

void Slic3r::GUI::UVEditorCanvas::rebuild_grid ( )

private

{
    // One line per UV unit (i.e. per texture tile), plus a subdivision when zoomed in far enough that
    // whole tiles would be too coarse to read.
    const float span = 2.f * m_zoom;
    float       step = 1.f;
    while (step > 0.01f && span / step > 40.f)
        step *= 2.f;
    while (span / step < 4.f)
        step *= 0.5f;
 
    // Cover exactly the currently-visible view rectangle (plus a one-step margin), recomputed on every
    // render. The old version only rebuilt when `step` changed, so panning at a fixed zoom left the grid
    // frozen at wherever it was last built - which is the "not in whole area / not always rendered while
    // moving" the user saw. The grid is only a few dozen lines, so rebuilding it per frame is cheap.
    float half_w, half_h;
    view_half_extents(half_w, half_h);
    const Vec2f lo = m_pan - Vec2f(half_w, half_h) - Vec2f(step, step);
    const Vec2f hi = m_pan + Vec2f(half_w, half_h) + Vec2f(step, step);
    m_grid_step    = step;
 
    const int first_x = int(std::floor(lo.x() / step)), last_x = int(std::ceil(hi.x() / step));
    const int first_y = int(std::floor(lo.y() / step)), last_y = int(std::ceil(hi.y() / step));
    if (last_x - first_x > 4000 || last_y - first_y > 4000)
        return; // degenerate zoom; not worth drawing a grid nobody can see
 
    GLModel::Geometry grid;
    grid.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
    unsigned index = 0;
    const auto line = [&](const Vec2f &a, const Vec2f &b) {
        grid.add_vertex(Vec3f(a.x(), a.y(), 0.f));
        grid.add_vertex(Vec3f(b.x(), b.y(), 0.f));
        grid.add_line(index, index + 1);
        index += 2;
    };
    for (int i = first_x; i <= last_x; ++i)
        line(Vec2f(float(i) * step, lo.y()), Vec2f(float(i) * step, hi.y()));
    for (int i = first_y; i <= last_y; ++i)
        line(Vec2f(lo.x(), float(i) * step), Vec2f(hi.x(), float(i) * step));
 
    m_grid_glmodel.reset();
    if (!grid.is_empty())
        m_grid_glmodel.init_from(std::move(grid));
}

References Slic3r::grid(), Slic3r::GUI::GLModel::Geometry::Lines, m_grid_glmodel, m_grid_step, m_pan, m_zoom, Slic3r::GUI::GLModel::Geometry::P3, and view_half_extents().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

rebuild_island_models()

void Slic3r::GUI::UVEditorCanvas::rebuild_island_models ( )

private

{
    m_mesh_dirty = false;
    m_island_wireframe.clear();
    m_island_fill.clear();
 
    const int islands = std::max(m_islands.island_count, 0);
    if (islands == 0 || m_islands.uvs.empty() || m_islands.indices.empty())
        return;
 
    m_island_wireframe.resize(size_t(islands));
    m_island_fill.resize(size_t(islands));
 
    const int vertex_count = int(m_islands.uvs.size());
 
    // Charts have disjoint vertex sets (compute_patch_unwrap() duplicates seam vertices per chart),
    // so every vertex belongs to exactly one island and this partition is clean.
    std::unordered_map<uint64_t, bool> is_boundary;
    is_boundary.reserve(m_islands.boundary_edges.size() * 2);
    for (const auto &[a, b] : m_islands.boundary_edges)
        is_boundary[undirected_edge_key(a, b)] = true;
 
    // Named, not size_t(islands) inline: the latter is a most-vexing-parse and declares a function
    // (a single identifier in the parens reads as a parameter name), which is what every
    // "subscript requires array or pointer type" error on these vectors was.
    const size_t n_islands = size_t(islands);
 
    // Global vertex index -> index within its own island's buffers.
    std::vector<int> local(m_islands.uvs.size(), -1);
    std::vector<std::vector<Vec2f>> island_verts(n_islands);
    for (size_t i = 0; i < m_islands.uvs.size(); ++i) {
        const int island = m_islands.vertex_island[i];
        if (island < 0 || island >= islands)
            continue;
        local[i] = int(island_verts[size_t(island)].size());
        island_verts[size_t(island)].push_back(m_islands.uvs[i]);
    }
 
    std::vector<GLModel::Geometry> wire(n_islands), fill(n_islands);
    for (int c = 0; c < islands; ++c) {
        wire[size_t(c)].format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
        fill[size_t(c)].format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3 };
        for (GLModel::Geometry *g : { &wire[size_t(c)], &fill[size_t(c)] }) {
            g->reserve_vertices(island_verts[size_t(c)].size());
            for (const Vec2f &uv : island_verts[size_t(c)])
                g->add_vertex(Vec3f(uv.x(), uv.y(), 0.f));
        }
    }
 
    for (const Vec3i32 &tri : m_islands.indices) {
        if (tri.minCoeff() < 0 || tri.maxCoeff() >= vertex_count)
            continue;
        const int island = m_islands.vertex_island[size_t(tri[0])];
        if (island < 0 || island >= islands)
            continue;
 
        fill[size_t(island)].add_triangle(unsigned(local[size_t(tri[0])]), unsigned(local[size_t(tri[1])]),
                                          unsigned(local[size_t(tri[2])]));
        // Interior edges only: the island outline is drawn separately, brighter and on top, so drawing
        // it here as well would just dim it by blending against itself.
        for (int i = 0; i < 3; ++i) {
            const int a = tri[i], b = tri[(i + 1) % 3];
            if (!is_boundary.count(undirected_edge_key(a, b)))
                wire[size_t(island)].add_line(unsigned(local[size_t(a)]), unsigned(local[size_t(b)]));
        }
    }
 
    for (int c = 0; c < islands; ++c) {
        if (!wire[size_t(c)].is_empty())
            m_island_wireframe[size_t(c)].init_from(std::move(wire[size_t(c)]));
        if (!fill[size_t(c)].is_empty())
            m_island_fill[size_t(c)].init_from(std::move(fill[size_t(c)]));
    }
}

References Slic3r::GUI::GLModel::Geometry::Lines, m_island_fill, m_island_wireframe, m_islands, m_mesh_dirty, Slic3r::GUI::GLModel::Geometry::P3, and Slic3r::GUI::GLModel::Geometry::Triangles.

Referenced by render().

Here is the caller graph for this function:

rebuild_rotation_dial()

void Slic3r::GUI::UVEditorCanvas::rebuild_rotation_dial ( )

private

{
    m_dial_glmodel.reset();
    const bool rotating = (m_gesture == Gesture::RotateIsland || m_gesture == Gesture::RotateIslandModal);
    if (!rotating || m_selected_island < 0)
        return;
 
    const wxSize size      = GetSize();
    const float  uv_per_px = 2.f * m_zoom / float(std::max(1, std::min(size.GetWidth(), size.GetHeight())));
    const float  radius    = 90.f * uv_per_px; // ~constant on-screen size regardless of zoom
    const Vec2f  centre    = island_centroid(m_selected_island);
 
    GLModel::Geometry dial;
    dial.format = { GLModel::Geometry::EPrimitiveType::Lines, GLModel::Geometry::EVertexLayout::P3 };
    unsigned index = 0;
    const auto line = [&](const Vec2f &a, const Vec2f &b) {
        dial.add_vertex(Vec3f(a.x(), a.y(), 0.f));
        dial.add_vertex(Vec3f(b.x(), b.y(), 0.f));
        dial.add_line(index, index + 1);
        index += 2;
    };
    const auto on_ring = [&](float deg, float r) {
        const float a = deg * float(M_PI) / 180.f;
        return centre + r * Vec2f(std::cos(a), std::sin(a));
    };
 
    // The ring itself.
    constexpr int SEG = 72;
    for (int i = 0; i < SEG; ++i)
        line(on_ring(float(i) * 360.f / SEG, radius), on_ring(float(i + 1) * 360.f / SEG, radius));
    // A tick every 15 degrees (the snap marks), longer on the cardinals.
    for (int d = 0; d < 360; d += 15) {
        const bool cardinal = (d % 90) == 0;
        line(on_ring(float(d), radius * (cardinal ? 0.80f : 0.90f)), on_ring(float(d), radius * (cardinal ? 1.08f : 1.0f)));
    }
    // The needle at the island's current absolute angle.
    line(centre, on_ring(m_rot_display_deg, radius * 1.12f));
 
    if (!dial.is_empty())
        m_dial_glmodel.init_from(std::move(dial));
}

References Slic3r::GUI::GLModel::Geometry::add_line(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::GUI::GLModel::Geometry::is_empty(), island_centroid(), Slic3r::GUI::GLModel::Geometry::Lines, m_dial_glmodel, m_gesture, M_PI, m_rot_display_deg, m_selected_island, m_zoom, Slic3r::GUI::GLModel::Geometry::P3, RotateIsland, and RotateIslandModal.

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

render()

void Slic3r::GUI::UVEditorCanvas::render ( )

private

{
    if (m_context == nullptr || !IsShownOnScreen())
        return;
    // Painted from inside a 3D canvas frame - a modal dialog the gizmo opened from its ImGui panel runs
    // this paint, as does any other synchronous event raised there. Making this surface current now
    // would take the shared context away from that canvas mid-frame: its remaining draws would land
    // here and, on Mesa/X11, its SwapBuffers() would be a fatal BadMatch. Skip, but ask for another
    // paint so the skipped one is not simply lost. The pane stays stale for as long as a nested modal
    // loop keeps a frame on the stack, which is behind the dialog anyway.
    if (GLCanvas3D::is_frame_in_progress()) {
        Refresh();
        return;
    }
 
    // wxGLCanvas::SetCurrent() genuinely fails (returns false) on a canvas that isn't shown on
    // screen, and can also fail on a pixel-format mismatch with the context - and every GL call
    // made afterwards would then run against whichever context *is* current, which here is the main
    // 3D canvas mid-frame. Bail instead of corrupting it.
    if (!SetCurrent(*m_context))
        return;
 
    // The context is shared with the 3D view, which leaves its own state behind: GLCanvas3D turns face culling on at
    // init and many of its passes turn it back on, and the pane's projection flips Y, so every triangle drawn here
    // faces away from it. With culling left on, the texture and the islands simply vanish - which is why they showed
    // the first time and were gone, fully or partly, after the 3D view had drawn. A scissor rectangle left on would
    // clip the clear and everything else the same way. Set what this pass relies on; put the 3D view's back after.
    const GLboolean prev_cull    = ::glIsEnabled(GL_CULL_FACE);
    const GLboolean prev_scissor = ::glIsEnabled(GL_SCISSOR_TEST);
    const GLboolean prev_stencil = ::glIsEnabled(GL_STENCIL_TEST);
    glsafe(::glDisable(GL_CULL_FACE));
    glsafe(::glDisable(GL_SCISSOR_TEST));
    glsafe(::glDisable(GL_STENCIL_TEST));
    glsafe(::glPolygonMode(GL_FRONT_AND_BACK, GL_FILL));
    glsafe(::glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE));
 
    if (m_gl_reset_pending) {
        m_gl_reset_pending = false;
        m_mesh_dirty       = true;
        m_background_dirty = true; // re-uploads m_background_pixels, or drops the texture if there are none
        m_tile_outline_glmodel.reset();
        m_vertex_marker_glmodel.reset();
        m_dim_quad_glmodel.reset();
        m_stroke_glmodel.reset();
        m_stencil_bits = -1;
    }
    if (m_mesh_dirty)
        rebuild_island_models();
    if (m_background_dirty)
        rebuild_background_texture();
    if (m_background_quad_dirty)
        rebuild_background_quad();
    if (m_needs_fit)
        fit_view_to_content();
    rebuild_grid();
    rebuild_rotation_dial();
 
    const wxSize size     = GetSize(); // logical points; the on-screen handle sizes below use it
    const wxSize viewport = gl_drawable_size(this, size);
    glsafe(::glViewport(0, 0, viewport.GetWidth(), viewport.GetHeight()));
    // Line widths below are authored in logical points (they are chosen against the same scale the
    // hit-test thresholds use), so they take the same logical -> device conversion as the viewport.
    const float px_scale   = float(viewport.GetWidth()) / float(std::max(1, size.GetWidth()));
    const auto  line_width = [px_scale](float w) { set_line_width(w * px_scale); };
    glsafe(::glClearColor(UV_COLOR_BG.r(), UV_COLOR_BG.g(), UV_COLOR_BG.b(), 1.f));
    glsafe(::glClearStencil(0));
    glsafe(::glStencilMask(0xFF));
    glsafe(::glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT));
    glsafe(::glDisable(GL_DEPTH_TEST));
    glsafe(::glEnable(GL_BLEND));
    glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
 
    // Orthographic, centered on m_pan. Y is negated so v runs down the screen, which is what puts
    // the texture's first pixel row (v = 0, see rebuild_background_quad()) at the top rather than
    // upside down.
    float half_w, half_h;
    view_half_extents(half_w, half_h);
 
    Transform3d projection_matrix = Transform3d::Identity();
    projection_matrix(0, 0)       =  1.0 / std::max(double(half_w), 1e-6);
    projection_matrix(1, 1)       = -1.0 / std::max(double(half_h), 1e-6);
    Transform3d view_matrix       = Transform3d::Identity();
    view_matrix.translate(Vec3d(-double(m_pan.x()), -double(m_pan.y()), 0.0));
 
    const auto draw_raw = [&](GLModel &model, const ColorRGBA &color, const Transform3d &view_model, const Transform3d &projection) {
        if (!model.is_initialized())
            return;
        GLShaderProgram *shader = wxGetApp().get_shader("flat");
        if (shader == nullptr)
            return;
        shader->start_using();
        shader->set_uniform("view_model_matrix", view_model);
        shader->set_uniform("projection_matrix", projection);
        model.set_color(color);
        model.render();
        shader->stop_using();
    };
    const auto draw = [&](GLModel &model, const ColorRGBA &color, const Transform3d &model_matrix) {
        draw_raw(model, color, view_matrix * model_matrix, projection_matrix);
    };
    const Transform3d identity = Transform3d::Identity();
 
    if (m_background_glmodel.is_initialized()) {
        if (GLShaderProgram *shader = wxGetApp().get_shader("flat_texture")) {
            shader->start_using();
            shader->set_uniform("view_model_matrix", view_matrix);
            shader->set_uniform("projection_matrix", projection_matrix);
            glsafe(::glActiveTexture(GL_TEXTURE0));
            glsafe(::glBindTexture(GL_TEXTURE_2D, m_background_texture.get_id()));
            // Repeat exactly the way DecodedHeightTexture::sample() does, so the backdrop under an
            // island really is the texels that island will sample. With tiling off, sample() returns
            // 0 outside the first tile - a black border, not a smeared edge, which is what
            // CLAMP_TO_BORDER reproduces (GLTexture's own default of GL_REPEAT would not).
            const GLint wrap = m_tile_enabled ? (m_tile_mirrored ? GL_MIRRORED_REPEAT : GL_REPEAT) : GL_CLAMP_TO_BORDER;
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap));
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap));
            if (!m_tile_enabled) {
                constexpr GLfloat border[4] = { 0.f, 0.f, 0.f, 1.f };
                glsafe(::glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border));
            }
            m_background_glmodel.render();
            glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
            shader->stop_using();
        }
    }
 
    const auto island_matrix = [this, &identity](int c) {
        return (size_t(c) < m_transforms.size()) ? to_transform3d(m_transforms[size_t(c)]) : identity;
    };
    const float uv_per_px = 2.f * m_zoom / float(std::max(1, std::min(size.GetWidth(), size.GetHeight())));
 
    // Strokes are built as quads `width_px` wide on screen, rebuilt every paint at the current zoom. Square caps
    // cover the joints of an outline; the colours passed here are opaque, so the overlapping caps don't show.
    using Segments           = std::vector<std::pair<Vec2f, Vec2f>>;
    const auto draw_segments = [&](const Segments &segments, float width_px, const ColorRGBA &color) {
        if (segments.empty())
            return;
        const float       half = 0.5f * width_px * uv_per_px;
        GLModel::Geometry quads;
        quads.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3 };
        quads.reserve_vertices(segments.size() * 4);
        quads.reserve_indices(segments.size() * 6);
        unsigned base = 0;
        for (const auto &[a, b] : segments) {
            const Vec2f d   = b - a;
            const float len = d.norm();
            if (len <= 1e-12f)
                continue;
            const Vec2f t = d * (half / len);
            const Vec2f n(-t.y(), t.x());
            for (const Vec2f &p : { Vec2f(a - t + n), Vec2f(a - t - n), Vec2f(b + t - n), Vec2f(b + t + n) })
                quads.add_vertex(Vec3f(p.x(), p.y(), 0.f));
            quads.add_triangle(base, base + 1, base + 2);
            quads.add_triangle(base, base + 2, base + 3);
            base += 4;
        }
        m_stroke_glmodel.reset();
        if (quads.is_empty())
            return;
        m_stroke_glmodel.init_from(std::move(quads));
        draw(m_stroke_glmodel, color, identity);
    };
    const auto draw_stroke = [&](const Segments &segments, float width_px, const ColorRGBA &color, float halo_px) {
        draw_segments(segments, width_px + 2.f * halo_px, UV_COLOR_HALO);
        draw_segments(segments, width_px, color);
    };
    const auto edge_segments = [this](const std::vector<std::pair<int, int>> &edges) {
        Segments out;
        out.reserve(edges.size());
        for (const auto &[a, b] : edges)
            if (a >= 0 && b >= 0 && size_t(a) < m_islands.uvs.size() && size_t(b) < m_islands.uvs.size())
                out.emplace_back(island_uv(size_t(a)), island_uv(size_t(b)));
        return out;
    };
 
    // Dim the texture everywhere but inside the islands: the fills go into the stencil only, then one
    // full-viewport quad washes the rest towards the background. Skipped without a stencil buffer, where the
    // quad would cover the islands too.
    if (m_stencil_bits < 0) {
        GLint bits = 0;
        ::glGetError(); // drop anything pending, so the check below sees only this query
        ::glGetIntegerv(GL_STENCIL_BITS, &bits); // compatibility profiles
        if (::glGetError() != GL_NO_ERROR) {
            bits = 0;
            ::glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, GL_STENCIL, GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, &bits);
            ::glGetError();
        }
        m_stencil_bits = std::max(0, int(bits));
    }
    if (has_islands() && !m_island_fill.empty() && m_stencil_bits > 0) {
        if (!m_dim_quad_glmodel.is_initialized()) {
            GLModel::Geometry q;
            q.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3 };
            q.add_vertex(Vec3f(-1.f, -1.f, 0.f));
            q.add_vertex(Vec3f(1.f, -1.f, 0.f));
            q.add_vertex(Vec3f(1.f, 1.f, 0.f));
            q.add_vertex(Vec3f(-1.f, 1.f, 0.f));
            q.add_triangle(0, 1, 2);
            q.add_triangle(0, 2, 3);
            m_dim_quad_glmodel.init_from(std::move(q));
        }
        glsafe(::glEnable(GL_STENCIL_TEST));
        glsafe(::glStencilFunc(GL_ALWAYS, 1, 0xFF));
        glsafe(::glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE));
        glsafe(::glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE));
        for (int c = 0; c < int(m_island_fill.size()); ++c)
            draw(m_island_fill[size_t(c)], ColorRGBA::WHITE(), island_matrix(c));
        glsafe(::glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE));
        glsafe(::glStencilFunc(GL_EQUAL, 0, 0xFF));
        glsafe(::glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP));
        draw_raw(m_dim_quad_glmodel, UV_COLOR_OUTSIDE, identity, identity);
        glsafe(::glDisable(GL_STENCIL_TEST));
    }
 
    line_width(1.f);
    draw(m_grid_glmodel, UV_COLOR_GRID, identity);
 
    // The texture's first tile. Always drawn, even with nothing painted, so the pane always has a
    // fixed landmark: the unwrap is packed in mm and divided by the tile size, so it is routinely
    // many tiles away from here, and without this there is no way to tell "the islands are somewhere
    // else" apart from "there are no islands".
    draw_stroke({ { Vec2f(0.f, 0.f), Vec2f(1.f, 0.f) }, { Vec2f(1.f, 0.f), Vec2f(1.f, 1.f) },
                  { Vec2f(1.f, 1.f), Vec2f(0.f, 1.f) }, { Vec2f(0.f, 1.f), Vec2f(0.f, 0.f) } },
                1.5f, UV_COLOR_TILE_OUTLINE, 1.f);
 
    // Island fills. Unselected islands get none, so the texture that will be baked shows unaltered; the one a
    // click would grab gets a light wash, the selection a teal one. A distortion heatmap (set_island_fill_colors)
    // replaces the default for unselected islands and is left alone by the hover wash.
    for (int c = 0; c < int(m_island_fill.size()); ++c) {
        ColorRGBA fill = size_t(c) < m_island_fill_colors.size() ? m_island_fill_colors[size_t(c)] : UV_COLOR_FILL;
        if (is_selected(c))
            fill = UV_COLOR_SEL_FILL;
        else if (c == m_hover_island && m_island_fill_colors.empty())
            fill = UV_COLOR_HOVER_FILL;
        if (fill.a() > 0.f)
            draw(m_island_fill[size_t(c)], fill, island_matrix(c));
    }
 
    // Interior edges stay GL lines (a patch can have a million of them), each with a dark copy one pixel down
    // and right, so the light wire still reads on a light texture.
    Transform3d shadow_projection = projection_matrix;
    shadow_projection.pretranslate(Vec3d(2.0 / std::max(1, size.GetWidth()), -2.0 / std::max(1, size.GetHeight()), 0.0));
    line_width(1.f);
    for (int c = 0; c < int(m_island_wireframe.size()); ++c) {
        draw_raw(m_island_wireframe[size_t(c)], UV_COLOR_WIRE_SHADOW, view_matrix * island_matrix(c), shadow_projection);
        draw(m_island_wireframe[size_t(c)], is_selected(c) ? UV_COLOR_SEL_WIRE : UV_COLOR_WIRE, island_matrix(c));
    }
 
    // The island outlines - i.e. exactly the edges the seam angle cut the patch along - because "where does one
    // island end and the next begin" is the single thing this pane exists to answer. Plain first, then the hovered
    // one, then the selection, so a highlighted outline is never overdrawn by its neighbour's.
    {
        std::vector<std::pair<int, int>> plain, hovered, selected;
        for (int c = 0; c < int(m_island_boundary_edges.size()); ++c) {
            auto &dst = is_selected(c) ? selected : (c == m_hover_island ? hovered : plain);
            dst.insert(dst.end(), m_island_boundary_edges[size_t(c)].begin(), m_island_boundary_edges[size_t(c)].end());
        }
        draw_stroke(edge_segments(plain), 1.5f, UV_COLOR_BOUNDARY, 1.25f);
        draw_stroke(edge_segments(hovered), 2.5f, UV_COLOR_HOVER, 1.5f);
        draw_stroke(edge_segments(selected), 3.f, UV_COLOR_SEL_BOUNDARY, 1.75f);
    }
 
    // The rotation protractor, on top of everything while a rotation gesture is live (#11).
    if (m_dial_glmodel.is_initialized()) {
        line_width(2.f);
        draw(m_dial_glmodel, UV_COLOR_DIAL, identity);
        line_width(1.f);
    }
 
    // Vertex/Edge mode: the element under the cursor in the hover colour, and the selection as teal - a selected
    // edge drawn over its whole length, a vertex as a square handle, both on a dark halo.
    if (!m_vertex_marker_glmodel.is_initialized()) {
        GLModel::Geometry q;
        q.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3 };
        q.reserve_vertices(4);
        q.reserve_indices(6);
        q.add_vertex(Vec3f(-0.5f, -0.5f, 0.f));
        q.add_vertex(Vec3f(0.5f, -0.5f, 0.f));
        q.add_vertex(Vec3f(0.5f, 0.5f, 0.f));
        q.add_vertex(Vec3f(-0.5f, 0.5f, 0.f));
        q.add_triangle(0, 1, 2);
        q.add_triangle(0, 2, 3);
        m_vertex_marker_glmodel.init_from(std::move(q));
    }
    const auto draw_marker = [&](int v, float px, const ColorRGBA &color) {
        if (v < 0 || size_t(v) >= m_islands.uvs.size())
            return;
        const Vec2f p = island_uv(size_t(v));
        Transform3d m = Transform3d::Identity();
        m.translate(Vec3d(double(p.x()), double(p.y()), 0.0));
        m.scale(double(px * uv_per_px));
        draw(m_vertex_marker_glmodel, color, m);
    };
    const auto draw_handle = [&](int v, const ColorRGBA &color, float px) {
        draw_marker(v, px + 4.f, UV_COLOR_HALO);
        draw_marker(v, px, color);
    };
    if (m_select_mode == SelectMode::Vertex) {
        if (m_hover_vertex >= 0 && !is_vertex_selected(m_hover_vertex))
            draw_handle(m_hover_vertex, UV_COLOR_HOVER, 7.f);
        // Every element of the multi-selection, falling back to the primary while the set is still empty.
        if (m_sel_vertices.empty())
            draw_handle(m_active_vertex, UV_COLOR_SEL_BOUNDARY, 8.f);
        else
            for (const int v : m_sel_vertices)
                draw_handle(v, UV_COLOR_SEL_BOUNDARY, 8.f);
    } else if (m_select_mode == SelectMode::Edge) {
        if (m_hover_edge.first >= 0 && !is_edge_selected(m_hover_edge))
            draw_stroke(edge_segments({ m_hover_edge }), 3.f, UV_COLOR_HOVER, 2.f);
        std::vector<std::pair<int, int>> edges = m_sel_edges;
        if (edges.empty() && m_active_edge.first >= 0)
            edges.push_back(m_active_edge);
        draw_stroke(edge_segments(edges), 4.f, UV_COLOR_SEL_BOUNDARY, 2.f);
        for (const auto &[a, b] : edges) {
            draw_handle(a, UV_COLOR_SEL_BOUNDARY, 6.f);
            draw_handle(b, UV_COLOR_SEL_BOUNDARY, 6.f);
        }
    }
 
    // Add/remove hint next to the cursor in Vertex/Edge mode: a green '+' when a click will add to the
    // selection (plain or Shift), a red '-' when Ctrl is held and a click will remove one - the UV-side
    // twin of the 3D paint cursor's own sign.
    if (m_select_mode != SelectMode::Island && m_cursor_inside) {
        const Vec2f centre   = screen_to_uv(m_cursor_px) + Vec2f(14.f, -14.f) * uv_per_px; // up-right of the pointer
        const float r        = 6.f * uv_per_px;
        const bool  removing = wxGetKeyState(WXK_CONTROL);
        Segments    sign{ { centre - Vec2f(r, 0.f), centre + Vec2f(r, 0.f) } }; // the '-' bar, shared by both signs
        if (!removing)
            sign.emplace_back(centre - Vec2f(0.f, r), centre + Vec2f(0.f, r)); // the extra stroke that makes it a '+'
        draw_stroke(sign, 2.5f, removing ? ColorRGBA(1.f, 0.36f, 0.30f, 1.f) : ColorRGBA(0.40f, 0.92f, 0.50f, 1.f), 1.f);
    }
 
    // The GL context is shared with the 3D view; leave the bits we touched as we found them.
    glsafe(::glDisable(GL_BLEND));
    glsafe(::glEnable(GL_DEPTH_TEST));
    if (prev_cull)
        glsafe(::glEnable(GL_CULL_FACE));
    if (prev_scissor)
        glsafe(::glEnable(GL_SCISSOR_TEST));
    if (prev_stencil)
        glsafe(::glEnable(GL_STENCIL_TEST));
 
    SwapBuffers();
 
    // Cheap, and render() runs on every gesture change (each Refresh), so the status line stays
    // current without threading update_status() through every mouse/key transition. The panel
    // guards against relayout when the text is unchanged.
    update_status();
}

References Slic3r::ColorRGBA::a(), Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::ColorRGBA::b(), Slic3r::GUI::draw(), Edge, fit_view_to_content(), Slic3r::GUI::GLModel::Geometry::format, Slic3r::ColorRGBA::g(), GL_ALWAYS, GL_BLEND, GL_CLAMP_TO_BORDER, GL_COLOR_BUFFER_BIT, GL_CULL_FACE, GL_DEPTH_TEST, GL_DRAW_FRAMEBUFFER, GL_EQUAL, GL_FALSE, GL_FILL, GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, GL_FRONT_AND_BACK, GL_KEEP, GL_MIRRORED_REPEAT, GL_NO_ERROR, GL_ONE_MINUS_SRC_ALPHA, GL_REPEAT, GL_REPLACE, GL_SCISSOR_TEST, GL_SRC_ALPHA, GL_STENCIL, GL_STENCIL_BITS, GL_STENCIL_BUFFER_BIT, GL_STENCIL_TEST, GL_TEXTURE0, GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TRUE, glActiveTexture, glBindTexture, glBlendFunc, glClear, glClearColor, glClearStencil, glColorMask, glDisable, glEnable, glGetError, glGetFramebufferAttachmentParameteriv, glGetIntegerv, glIsEnabled, glPolygonMode, glsafe, glStencilFunc, glStencilMask, glStencilOp, glTexParameterfv, glTexParameteri, glViewport, has_islands(), Slic3r::identity(), is_edge_selected(), Slic3r::GUI::GLModel::Geometry::is_empty(), Slic3r::GUI::GLCanvas3D::is_frame_in_progress(), Slic3r::GUI::GLModel::is_initialized(), is_selected(), is_vertex_selected(), Island, island_uv(), m_active_edge, m_active_vertex, m_background_dirty, m_background_glmodel, m_background_quad_dirty, m_background_texture, m_context, m_cursor_inside, m_cursor_px, m_dial_glmodel, m_dim_quad_glmodel, m_gl_reset_pending, m_grid_glmodel, m_hover_edge, m_hover_island, m_hover_vertex, m_island_boundary_edges, m_island_fill, m_island_fill_colors, m_island_wireframe, m_islands, m_mesh_dirty, m_needs_fit, m_pan, m_sel_edges, m_sel_vertices, m_select_mode, m_stencil_bits, m_stroke_glmodel, m_tile_enabled, m_tile_mirrored, m_tile_outline_glmodel, m_transforms, m_vertex_marker_glmodel, m_zoom, Slic3r::GUI::GLModel::Geometry::P3, Slic3r::ColorRGBA::r(), rebuild_background_quad(), rebuild_background_texture(), rebuild_grid(), rebuild_island_models(), rebuild_rotation_dial(), Slic3r::GUI::GLModel::render(), Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), screen_to_uv(), Slic3r::GUI::GLModel::set_color(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), Slic3r::GUI::GLModel::Geometry::Triangles, update_status(), Vertex, view_half_extents(), and Slic3r::ColorRGBA::WHITE().

Referenced by on_paint().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_view()

void Slic3r::GUI::UVEditorCanvas::reset_view

(

)

{
    m_needs_fit = true;
    Refresh();
}

References m_needs_fit.

Referenced by on_key(), and run_command().

Here is the caller graph for this function:

run_command()

void Slic3r::GUI::UVEditorCanvas::run_command	(	Command	cmd,
		float	value = 0.f )

{
    switch (cmd) {
    case Command::FrameAll:   reset_view(); return;
    case Command::ToggleSnap: m_snap_enabled = !m_snap_enabled; update_status(); return;
    case Command::SetSelectMode:
        // Switched here straight away so the strip and the canvas agree at once; the gizmo is still told,
        // because it is what keeps the mode when the canvas is next refreshed from the layer.
        set_select_mode(static_cast<SelectMode>(std::clamp(int(value), 0, 2)));
        break;
    default: break;
    }
    // Everything else needs the layer data the canvas doesn't hold; hand it to the gizmo.
    if (m_on_command)
        m_on_command(cmd, value);
}

References FrameAll, m_on_command, m_snap_enabled, reset_view(), set_select_mode(), SetSelectMode, ToggleSnap, and update_status().

Referenced by on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

screen_to_uv()

Vec2f Slic3r::GUI::UVEditorCanvas::screen_to_uv ( const wxPoint & px ) const

private

{
    const wxSize size = GetSize();
    const float  w    = float(std::max(1, size.GetWidth()));
    const float  h    = float(std::max(1, size.GetHeight()));
 
    float half_w, half_h;
    view_half_extents(half_w, half_h);
 
    // Inverse of the projection in render(): x maps straight through, y is negated there so that v
    // runs down the screen - which means screen-down and v-increasing agree, and this is a plain
    // scale on both axes.
    return Vec2f(m_pan.x() + (2.f * float(px.x) / w - 1.f) * half_w,
                 m_pan.y() + (2.f * float(px.y) / h - 1.f) * half_h);
}

References m_pan, and view_half_extents().

Referenced by on_key(), on_mouse(), render(), and update_hover().

Here is the call graph for this function:

Here is the caller graph for this function:

select_mode()

SelectMode Slic3r::GUI::UVEditorCanvas::select_mode ( ) const

inline

{ return m_select_mode; }

References m_select_mode.

selected_edge_endpoints()

std::vector< int > Slic3r::GUI::UVEditorCanvas::selected_edge_endpoints ( ) const

private

{
    std::vector<int> verts;
    for (const auto &[a, b] : m_sel_edges)
        for (const int v : { a, b })
            if (v >= 0 && std::find(verts.begin(), verts.end(), v) == verts.end())
                verts.push_back(v);
    return verts;
}

References m_sel_edges.

Referenced by end_gesture(), and on_mouse().

Here is the caller graph for this function:

selected_island()

int Slic3r::GUI::UVEditorCanvas::selected_island ( ) const

inline

{ return m_selected_island; }

References m_selected_island.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::run_uv_command().

Here is the caller graph for this function:

selected_islands()

const std::vector< int > & Slic3r::GUI::UVEditorCanvas::selected_islands ( ) const

inline

{ return m_selection; }

References m_selection.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::island_highlight_selection().

Here is the caller graph for this function:

set_background_texture()

void Slic3r::GUI::UVEditorCanvas::set_background_texture	(	const std::vector< unsigned char > &	grayscale_pixels,
		int	width,
		int	height )

{
    if (width <= 0 || height <= 0 || grayscale_pixels.size() != size_t(width) * size_t(height)) {
        m_background_width = m_background_height = 0;
        m_background_pixels.clear();
    } else {
        m_background_width  = width;
        m_background_height = height;
        m_background_pixels.assign(size_t(width) * size_t(height) * 4, 255);
        for (size_t i = 0; i < grayscale_pixels.size(); ++i) {
            const unsigned char g          = grayscale_pixels[i];
            m_background_pixels[i * 4 + 0] = g;
            m_background_pixels[i * 4 + 1] = g;
            m_background_pixels[i * 4 + 2] = g;
            m_background_pixels[i * 4 + 3] = 255;
        }
    }
    m_background_dirty = true;
    Refresh();
}

References m_background_dirty, m_background_height, m_background_pixels, and m_background_width.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::update_uv_editor().

Here is the caller graph for this function:

set_command_callback()

void Slic3r::GUI::UVEditorCanvas::set_command_callback ( CommandFn fn )

inline

{ m_on_command = std::move(fn); }

References m_on_command.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::update_uv_editor().

Here is the caller graph for this function:

set_island_edit_callback()

void Slic3r::GUI::UVEditorCanvas::set_island_edit_callback ( IslandEditFn fn )

inline

{ m_on_island_edit = std::move(fn); }

References m_on_island_edit.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::update_uv_editor().

Here is the caller graph for this function:

set_island_fill_colors()

void Slic3r::GUI::UVEditorCanvas::set_island_fill_colors

(

std::vector< ColorRGBA >

colors

)

{
    m_island_fill_colors = std::move(colors);
    Refresh();
}

References m_island_fill_colors.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::update_uv_editor().

Here is the caller graph for this function:

set_island_transforms()

void Slic3r::GUI::UVEditorCanvas::set_island_transforms

(

std::vector< IslandTransform >

transforms

)

{
    m_transforms            = std::move(transforms);
    m_background_quad_dirty = true; // content_bounds() depends on where the islands ended up
    Refresh();
}

References m_background_quad_dirty, and m_transforms.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::update_uv_editor().

Here is the caller graph for this function:

set_islands()

void Slic3r::GUI::UVEditorCanvas::set_islands

(

Islands

islands

)

{
    // Only frame the view when a patch first appears, not on every stroke that extends one - the
    // latter would keep yanking the view out from under a user who has panned or zoomed.
    m_needs_fit |= m_islands.indices.empty();
    // Re-uploads that keep the same island/vertex count are just a refresh (e.g. a committed vertex edit
    // re-applied), not a re-segmentation, so the selection and the picked sub-element stay valid and are
    // worth keeping. A change in either count means the charts were renumbered and both are meaningless.
    const bool same_structure = m_islands.island_count == islands.island_count &&
                                m_islands.uvs.size() == islands.uvs.size();
    m_islands    = std::move(islands);
    if (m_selected_island >= m_islands.island_count)
        m_selected_island = -1;
    if (!same_structure) {
        // A fresh unwrap renumbers charts, so any previous multi-selection is meaningless: drop it, then
        // keep the primary (if still valid) as a single-island selection so the highlight is consistent.
        m_selection.clear();
        if (m_selected_island >= 0)
            m_selection.push_back(m_selected_island);
        // Vertex/edge picks index into the old unwrap; drop them too.
        m_active_vertex = -1;
        m_active_edge   = { -1, -1 };
        m_sel_vertices.clear();
        m_sel_edges.clear();
        m_hover_island = m_hover_vertex = -1;
        m_hover_edge   = { -1, -1 };
    }
 
    // Boundary vertices and edges, bucketed per island: the vertices for snapping, the edges for the outline.
    const size_t n_islands = size_t(std::max(m_islands.island_count, 0));
    m_island_boundary_verts.assign(n_islands, {});
    m_island_boundary_edges.assign(n_islands, {});
    std::vector<bool> seen(m_islands.uvs.size(), false);
    for (const auto &[a, b] : m_islands.boundary_edges) {
        if (a < 0 || b < 0 || size_t(a) >= m_islands.uvs.size() || size_t(b) >= m_islands.uvs.size())
            continue;
        const int island = m_islands.vertex_island[size_t(a)];
        if (island < 0 || size_t(island) >= n_islands)
            continue;
        m_island_boundary_edges[size_t(island)].emplace_back(a, b);
        for (const int v : { a, b })
            if (!seen[size_t(v)]) {
                seen[size_t(v)] = true;
                m_island_boundary_verts[size_t(island)].push_back(v);
            }
    }
 
    // Triangles and raw bounds per island, for picking.
    m_island_tris.assign(n_islands, {});
    m_island_raw_bounds.assign(n_islands, { Vec2f::Constant(std::numeric_limits<float>::max()),
                                            Vec2f::Constant(std::numeric_limits<float>::lowest()) });
    for (size_t t = 0; t < m_islands.indices.size(); ++t) {
        const Vec3i32 &tri = m_islands.indices[t];
        if (tri.minCoeff() < 0 || size_t(tri.maxCoeff()) >= m_islands.uvs.size())
            continue;
        const int island = m_islands.vertex_island[size_t(tri[0])];
        if (island < 0 || size_t(island) >= n_islands)
            continue;
        m_island_tris[size_t(island)].push_back(int(t));
        auto &[lo, hi] = m_island_raw_bounds[size_t(island)];
        for (int k = 0; k < 3; ++k) {
            lo = lo.cwiseMin(m_islands.uvs[size_t(tri[k])]);
            hi = hi.cwiseMax(m_islands.uvs[size_t(tri[k])]);
        }
    }
 
    m_mesh_dirty            = true;
    m_background_quad_dirty = true; // the backdrop is sized to the unwrap, so it moved too
    Refresh();
}

References Slic3r::GUI::UVEditorCanvas::Islands::island_count, m_active_edge, m_active_vertex, m_background_quad_dirty, m_hover_edge, m_hover_island, m_hover_vertex, m_island_boundary_edges, m_island_boundary_verts, m_island_raw_bounds, m_island_tris, m_islands, m_mesh_dirty, m_needs_fit, m_sel_edges, m_sel_vertices, m_selected_island, m_selection, and Slic3r::GUI::UVEditorCanvas::Islands::uvs.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::update_uv_editor().

Here is the caller graph for this function:

set_pane_state()

void Slic3r::GUI::UVEditorCanvas::set_pane_state

(

PaneState

state

)

{
    m_pane_state = std::move(state);
    update_status();
    if (m_on_pane_state)
        m_on_pane_state(m_pane_state);
}

References m_on_pane_state, m_pane_state, and update_status().

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::push_uv_pane_state().

Here is the call graph for this function:

Here is the caller graph for this function:

set_pane_state_callback()

void Slic3r::GUI::UVEditorCanvas::set_pane_state_callback ( PaneStateFn fn )

inline

{ m_on_pane_state = std::move(fn); }

References m_on_pane_state.

set_select_mode()

void Slic3r::GUI::UVEditorCanvas::set_select_mode

(

SelectMode

mode

)

{
    if (m_select_mode == mode)
        return;
    m_select_mode   = mode;
    m_active_vertex = -1;
    m_active_edge   = { -1, -1 };
    m_hover_island  = m_hover_vertex = -1;
    m_hover_edge    = { -1, -1 };
    m_sel_vertices.clear();
    m_sel_edges.clear();
    m_gesture       = Gesture::None;
    update_status();
    Refresh();
}

References m_active_edge, m_active_vertex, m_gesture, m_hover_edge, m_hover_island, m_hover_vertex, m_sel_edges, m_sel_vertices, m_select_mode, None, and update_status().

Referenced by run_command(), and Slic3r::GUI::GLGizmoTextureDisplacement::update_uv_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

set_snap_enabled()

void Slic3r::GUI::UVEditorCanvas::set_snap_enabled ( bool enabled )

inline

{ m_snap_enabled = enabled; }

References m_snap_enabled.

set_status_callback()

void Slic3r::GUI::UVEditorCanvas::set_status_callback ( StatusFn fn )

inline

{ m_on_status = std::move(fn); }

References m_on_status.

set_uv_transform()

void Slic3r::GUI::UVEditorCanvas::set_uv_transform	(	float	tiling_scale,
		float	rotation_deg,
		bool	tile_enabled,
		bool	tile_mirrored )

{
    m_tiling_scale          = (std::abs(tiling_scale) > 1e-6f) ? tiling_scale : 1.f;
    m_rotation_deg          = rotation_deg;
    m_tile_enabled          = tile_enabled;
    m_tile_mirrored         = tile_mirrored;
    m_background_quad_dirty = true;
}

References m_background_quad_dirty, m_rotation_deg, m_tile_enabled, m_tile_mirrored, and m_tiling_scale.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::update_uv_editor().

Here is the caller graph for this function:

set_vertex_edit_callback()

void Slic3r::GUI::UVEditorCanvas::set_vertex_edit_callback ( UVVertexEditFn fn )

inline

{ m_on_vertex_edit = std::move(fn); }

References m_on_vertex_edit.

Referenced by Slic3r::GUI::GLGizmoTextureDisplacement::update_uv_editor().

Here is the caller graph for this function:

snap_correction()

Vec2f Slic3r::GUI::UVEditorCanvas::snap_correction ( int island ) const

private

{
    if (!m_snap_enabled || island < 0 || size_t(island) >= m_island_boundary_verts.size())
        return Vec2f::Zero();
 
    // A screen-space threshold, so the magnet feels the same at every zoom level.
    const wxSize size      = GetSize();
    const float  uv_per_px = 2.f * m_zoom / float(std::max(1, std::min(size.GetWidth(), size.GetHeight())));
    const float  threshold = SNAP_PIXELS * uv_per_px;
 
    float best_dist_sq = threshold * threshold;
    Vec2f best         = Vec2f::Zero();
    for (const int mine : m_island_boundary_verts[size_t(island)]) {
        const Vec2f a = island_uv(size_t(mine));
        for (size_t other = 0; other < m_island_boundary_verts.size(); ++other) {
            if (int(other) == island)
                continue;
            for (const int theirs : m_island_boundary_verts[other]) {
                const Vec2f d       = island_uv(size_t(theirs)) - a;
                const float dist_sq = d.squaredNorm();
                if (dist_sq < best_dist_sq) {
                    best_dist_sq = dist_sq;
                    best         = d;
                }
            }
        }
    }
    return best;
}

References island_uv(), m_island_boundary_verts, m_snap_enabled, and m_zoom.

Referenced by end_gesture().

Here is the call graph for this function:

Here is the caller graph for this function:

snap_enabled()

bool Slic3r::GUI::UVEditorCanvas::snap_enabled ( ) const

inline

{ return m_snap_enabled; }

References m_snap_enabled.

update_hover()

void Slic3r::GUI::UVEditorCanvas::update_hover ( const wxPoint & pos )

private

{
    int                 island = -1, vertex = -1;
    std::pair<int, int> edge{ -1, -1 };
    if (has_islands()) {
        const Vec2f uv = screen_to_uv(pos);
        switch (m_select_mode) {
        case SelectMode::Island: island = island_at(uv); break;
        case SelectMode::Vertex: vertex = vertex_at(uv); break;
        case SelectMode::Edge:   edge = edge_at(uv); break;
        }
    }
    if (island != m_hover_island || vertex != m_hover_vertex || edge != m_hover_edge) {
        m_hover_island = island;
        m_hover_vertex = vertex;
        m_hover_edge   = edge;
        Refresh();
    }
}

References Edge, edge_at(), has_islands(), Island, island_at(), m_hover_edge, m_hover_island, m_hover_vertex, m_select_mode, screen_to_uv(), Vertex, and vertex_at().

Referenced by on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

update_status()

void Slic3r::GUI::UVEditorCanvas::update_status ( )

private

{
    if (!m_on_status)
        return;
 
    wxString msg;
    switch (m_gesture) {
    case Gesture::MoveIsland:        msg = _L("Moving island  |  release to drop, Esc to cancel"); break;
    case Gesture::RotateIsland:
    case Gesture::RotateIslandModal:
        msg = wxString::Format(_L("Rotating island: %d°  |  Shift = snap 15°, click to confirm, Esc to cancel"),
                                int(std::lround(m_rot_display_deg)));
        break;
    case Gesture::ScaleIslandModal:  msg = _L("Scaling island  |  click to confirm, Esc to cancel"); break;
    case Gesture::MoveVertex:        msg = _L("Moving vertex  |  release to drop"); break;
    case Gesture::MoveEdge:          msg = _L("Moving edge  |  release to drop"); break;
    case Gesture::Pan:               msg = _L("Panning"); break;
    case Gesture::None:
    default:
        if (!has_islands())
            msg = m_pane_state.has_layer ? _L("Paint the area on the model, then press Unwrap") :
                                           _L("Pick Unwrap as a texture layer's mapping to edit its UVs here");
        else if (m_select_mode == SelectMode::Vertex)
            msg = m_sel_vertices.size() > 1 ?
                      wxString::Format(_L_PLURAL("%d vertex selected  |  drag = move together, Shift/Ctrl click = add/remove",
                                                 "%d vertices selected  |  drag = move together, Shift/Ctrl click = add/remove",
                                                 m_sel_vertices.size()),
                                       int(m_sel_vertices.size())) :
                      _L("Vertex mode: drag a vertex to reshape  |  Shift/Ctrl click = multi-select, wheel = zoom, Home = frame");
        else if (m_select_mode == SelectMode::Edge)
            msg = m_sel_edges.size() > 1 ?
                      wxString::Format(_L_PLURAL("%d edge selected  |  drag = move together, Shift/Ctrl click = add/remove",
                                                 "%d edges selected  |  drag = move together, Shift/Ctrl click = add/remove",
                                                 m_sel_edges.size()),
                                       int(m_sel_edges.size())) :
                      _L("Edge mode: drag an island edge to reshape  |  Shift/Ctrl click = multi-select, wheel = zoom, Home = frame");
        else if (m_selection.size() > 1)
            msg = wxString::Format(_L_PLURAL("%d island selected  |  drag = move together, Shift/Ctrl click = add/remove, R/S = rotate/scale primary",
                                             "%d islands selected  |  drag = move together, Shift/Ctrl click = add/remove, R/S = rotate/scale primary",
                                             m_selection.size()),
                                    int(m_selection.size()));
        else if (m_selected_island >= 0)
            msg = wxString::Format(_L("Island %d selected  |  drag = move, R = rotate, S = scale, Shift/Ctrl click = multi-select, Home = frame"),
                                    m_selected_island + 1);
        else
            msg = _L("Click an island to select  |  Shift/Ctrl click = multi-select, wheel = zoom, middle-drag = pan, Home = frame all");
        if (m_snap_enabled)
            msg += _L("  |  snap ON");
        break;
    }
    m_on_status(msg);
}

References _L, _L_PLURAL, Edge, has_islands(), m_gesture, m_on_status, m_pane_state, m_rot_display_deg, m_sel_edges, m_sel_vertices, m_select_mode, m_selected_island, m_selection, m_snap_enabled, MoveEdge, MoveIsland, MoveVertex, None, Pan, RotateIsland, RotateIslandModal, ScaleIslandModal, and Vertex.

Referenced by render(), run_command(), set_pane_state(), and set_select_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

uv_delta_to_unwrap()

Vec2f Slic3r::GUI::UVEditorCanvas::uv_delta_to_unwrap ( const Vec2f & delta_uv ) const

private

{
    // apply_uv_transform() maps unwrap -> uv as  uv = R(unwrap / tiling) + offset, so the inverse of
    // a *delta* (the translation drops out) is  unwrap = tiling * R^-1(delta_uv).
    const float rad = m_rotation_deg * float(M_PI) / 180.f;
    const float cs = std::cos(rad), sn = std::sin(rad);
    return Vec2f(delta_uv.x() * cs + delta_uv.y() * sn, -delta_uv.x() * sn + delta_uv.y() * cs) * m_tiling_scale;
}

References M_PI, m_rotation_deg, and m_tiling_scale.

Referenced by end_gesture(), and on_mouse().

Here is the caller graph for this function:

vertex_at()

int Slic3r::GUI::UVEditorCanvas::vertex_at ( const Vec2f & uv ) const

private

{
    // Screen-space threshold, so the pick feels the same at every zoom.
    const wxSize size      = GetSize();
    const float  uv_per_px = 2.f * m_zoom / float(std::max(1, std::min(size.GetWidth(), size.GetHeight())));
    const float  threshold = SNAP_PIXELS * uv_per_px;
 
    int   best   = -1;
    float best_d = threshold * threshold;
    for (size_t i = 0; i < m_islands.uvs.size(); ++i) {
        const float d = (island_uv(i) - uv).squaredNorm();
        if (d < best_d) {
            best_d = d;
            best   = int(i);
        }
    }
    return best;
}

References island_uv(), m_islands, and m_zoom.

Referenced by on_mouse(), and update_hover().

Here is the call graph for this function:

Here is the caller graph for this function:

view_half_extents()

void Slic3r::GUI::UVEditorCanvas::view_half_extents ( float & half_w, float & half_h ) const

private

{
    const wxSize size = GetSize();
    const float  w    = float(std::max(1, size.GetWidth()));
    const float  h    = float(std::max(1, size.GetHeight()));
 
    // m_zoom is the half-extent visible across the *shorter* edge; the longer edge shows
    // proportionally more. Both axes have to be driven off the same uniform scale, or the content
    // comes out squashed on one of the two pane orientations.
    const float aspect = w / h;
    half_w             = m_zoom * std::max(aspect, 1.f);
    half_h             = m_zoom * std::max(1.f / aspect, 1.f);
}

References m_zoom.

Referenced by rebuild_grid(), render(), and screen_to_uv().

Here is the caller graph for this function:

Member Data Documentation

m_active_edge

std::pair<int, int> Slic3r::GUI::UVEditorCanvas::m_active_edge { -1, -1 }

private

{ -1, -1 };

Referenced by end_gesture(), on_mouse(), render(), set_islands(), and set_select_mode().

m_active_vertex

int Slic3r::GUI::UVEditorCanvas::m_active_vertex = -1

private

Referenced by end_gesture(), on_mouse(), render(), set_islands(), and set_select_mode().

m_background_dirty

bool Slic3r::GUI::UVEditorCanvas::m_background_dirty = false

private

Referenced by rebuild_background_texture(), render(), and set_background_texture().

m_background_glmodel

GLModel Slic3r::GUI::UVEditorCanvas::m_background_glmodel

private

Referenced by rebuild_background_quad(), and render().

m_background_height

int Slic3r::GUI::UVEditorCanvas::m_background_height = 0

private

Referenced by rebuild_background_quad(), rebuild_background_texture(), and set_background_texture().

m_background_pixels

std::vector<unsigned char> Slic3r::GUI::UVEditorCanvas::m_background_pixels

private

Referenced by rebuild_background_texture(), and set_background_texture().

m_background_quad_dirty

bool Slic3r::GUI::UVEditorCanvas::m_background_quad_dirty = true

private

Referenced by rebuild_background_quad(), rebuild_background_texture(), render(), set_island_transforms(), set_islands(), and set_uv_transform().

m_background_texture

GLTexture Slic3r::GUI::UVEditorCanvas::m_background_texture

private

Referenced by rebuild_background_texture(), and render().

m_background_width

int Slic3r::GUI::UVEditorCanvas::m_background_width = 0

private

Referenced by rebuild_background_quad(), rebuild_background_texture(), and set_background_texture().

m_context

wxGLContext* Slic3r::GUI::UVEditorCanvas::m_context = nullptr

private

Referenced by UVEditorCanvas(), and render().

m_cursor_inside

bool Slic3r::GUI::UVEditorCanvas::m_cursor_inside = false

private

Referenced by on_leave(), on_mouse(), and render().

m_cursor_px

wxPoint Slic3r::GUI::UVEditorCanvas::m_cursor_px { 0, 0 }

private

{ 0, 0 };

Referenced by on_mouse(), and render().

m_dial_glmodel

GLModel Slic3r::GUI::UVEditorCanvas::m_dial_glmodel

private

Referenced by rebuild_rotation_dial(), and render().

m_dim_quad_glmodel

GLModel Slic3r::GUI::UVEditorCanvas::m_dim_quad_glmodel

private

Referenced by render().

m_drag_last_px

wxPoint Slic3r::GUI::UVEditorCanvas::m_drag_last_px

private

Referenced by on_mouse().

m_gesture

Gesture Slic3r::GUI::UVEditorCanvas::m_gesture = Gesture::None

private

Referenced by cancel_gesture(), end_gesture(), on_key(), on_leave(), on_mouse(), rebuild_rotation_dial(), set_select_mode(), and update_status().

m_gesture_last_angle

float Slic3r::GUI::UVEditorCanvas::m_gesture_last_angle = 0.f

private

Referenced by on_key(), and on_mouse().

m_gesture_last_dist

float Slic3r::GUI::UVEditorCanvas::m_gesture_last_dist = 0.f

private

Referenced by on_key(), and on_mouse().

m_gesture_last_uv

Vec2f Slic3r::GUI::UVEditorCanvas::m_gesture_last_uv = Vec2f::Zero()

private

Referenced by on_mouse().

m_gl_reset_pending

bool Slic3r::GUI::UVEditorCanvas::m_gl_reset_pending = false

private

Referenced by invalidate_gl(), and render().

m_grid_glmodel

GLModel Slic3r::GUI::UVEditorCanvas::m_grid_glmodel

private

Referenced by rebuild_grid(), and render().

m_grid_step

float Slic3r::GUI::UVEditorCanvas::m_grid_step = 0.f

private

Referenced by rebuild_grid().

m_hover_edge

std::pair<int, int> Slic3r::GUI::UVEditorCanvas::m_hover_edge { -1, -1 }

private

{ -1, -1 };

Referenced by on_leave(), render(), set_islands(), set_select_mode(), and update_hover().

m_hover_island

int Slic3r::GUI::UVEditorCanvas::m_hover_island = -1

private

Referenced by on_leave(), render(), set_islands(), set_select_mode(), and update_hover().

m_hover_vertex

int Slic3r::GUI::UVEditorCanvas::m_hover_vertex = -1

private

Referenced by on_leave(), render(), set_islands(), set_select_mode(), and update_hover().

m_island_boundary_edges

std::vector<std::vector<std::pair<int, int> > > Slic3r::GUI::UVEditorCanvas::m_island_boundary_edges

private

Referenced by render(), and set_islands().

m_island_boundary_verts

std::vector<std::vector<int> > Slic3r::GUI::UVEditorCanvas::m_island_boundary_verts

private

Referenced by set_islands(), and snap_correction().

m_island_fill

std::vector<GLModel> Slic3r::GUI::UVEditorCanvas::m_island_fill

private

Referenced by rebuild_island_models(), and render().

m_island_fill_colors

std::vector<ColorRGBA> Slic3r::GUI::UVEditorCanvas::m_island_fill_colors

private

Referenced by render(), and set_island_fill_colors().

m_island_raw_bounds

std::vector<std::pair<Vec2f, Vec2f> > Slic3r::GUI::UVEditorCanvas::m_island_raw_bounds

private

Referenced by island_at(), move_vertex_raw(), and set_islands().

m_island_tris

std::vector<std::vector<int> > Slic3r::GUI::UVEditorCanvas::m_island_tris

private

Referenced by island_at(), and set_islands().

m_island_wireframe

std::vector<GLModel> Slic3r::GUI::UVEditorCanvas::m_island_wireframe

private

Referenced by rebuild_island_models(), and render().

m_islands

Islands Slic3r::GUI::UVEditorCanvas::m_islands

private

Referenced by content_bounds(), edge_at(), end_gesture(), has_islands(), island_at(), island_centroid(), island_uv(), move_vertex_raw(), rebuild_island_models(), render(), set_islands(), and vertex_at().

m_mesh_dirty

bool Slic3r::GUI::UVEditorCanvas::m_mesh_dirty = true

private

Referenced by move_vertex_raw(), rebuild_island_models(), render(), and set_islands().

m_modal_scale_accum

float Slic3r::GUI::UVEditorCanvas::m_modal_scale_accum = 1.f

private

Referenced by cancel_gesture(), end_gesture(), on_key(), and on_mouse().

m_needs_fit

bool Slic3r::GUI::UVEditorCanvas::m_needs_fit = true

private

Referenced by fit_view_to_content(), render(), reset_view(), and set_islands().

m_on_command

CommandFn Slic3r::GUI::UVEditorCanvas::m_on_command

private

Referenced by run_command(), and set_command_callback().

m_on_island_edit

IslandEditFn Slic3r::GUI::UVEditorCanvas::m_on_island_edit

private

Referenced by cancel_gesture(), end_gesture(), on_key(), on_mouse(), and set_island_edit_callback().

m_on_pane_state

PaneStateFn Slic3r::GUI::UVEditorCanvas::m_on_pane_state

private

Referenced by set_pane_state(), and set_pane_state_callback().

m_on_status

StatusFn Slic3r::GUI::UVEditorCanvas::m_on_status

private

Referenced by set_status_callback(), and update_status().

m_on_vertex_edit

UVVertexEditFn Slic3r::GUI::UVEditorCanvas::m_on_vertex_edit

private

Referenced by end_gesture(), and set_vertex_edit_callback().

m_pan

Vec2f Slic3r::GUI::UVEditorCanvas::m_pan = Vec2f(0.5f, 0.5f)

private

Referenced by fit_view_to_content(), on_mouse(), rebuild_grid(), render(), and screen_to_uv().

m_pane_state

PaneState Slic3r::GUI::UVEditorCanvas::m_pane_state

private

Referenced by pane_state(), set_pane_state(), and update_status().

m_rot_applied_deg

float Slic3r::GUI::UVEditorCanvas::m_rot_applied_deg = 0.f

private

Referenced by cancel_gesture(), end_gesture(), on_key(), and on_mouse().

m_rot_base_deg

float Slic3r::GUI::UVEditorCanvas::m_rot_base_deg = 0.f

private

Referenced by on_key(), and on_mouse().

m_rot_display_deg

float Slic3r::GUI::UVEditorCanvas::m_rot_display_deg = 0.f

private

Referenced by on_key(), on_mouse(), rebuild_rotation_dial(), and update_status().

m_rot_raw_deg

float Slic3r::GUI::UVEditorCanvas::m_rot_raw_deg = 0.f

private

Referenced by cancel_gesture(), end_gesture(), on_key(), and on_mouse().

m_rotation_deg

float Slic3r::GUI::UVEditorCanvas::m_rotation_deg = 0.f

private

Referenced by set_uv_transform(), and uv_delta_to_unwrap().

m_sel_edges

std::vector<std::pair<int, int> > Slic3r::GUI::UVEditorCanvas::m_sel_edges

private

Referenced by is_edge_selected(), on_mouse(), render(), selected_edge_endpoints(), set_islands(), set_select_mode(), and update_status().

m_sel_vertices

std::vector<int> Slic3r::GUI::UVEditorCanvas::m_sel_vertices

private

Referenced by end_gesture(), is_vertex_selected(), on_mouse(), render(), set_islands(), set_select_mode(), and update_status().

m_select_mode

SelectMode Slic3r::GUI::UVEditorCanvas::m_select_mode = SelectMode::Island

private

Referenced by on_key(), on_mouse(), render(), select_mode(), set_select_mode(), update_hover(), and update_status().

m_selected_island

int Slic3r::GUI::UVEditorCanvas::m_selected_island = -1

private

Referenced by cancel_gesture(), end_gesture(), on_key(), on_mouse(), rebuild_rotation_dial(), selected_island(), set_islands(), and update_status().

m_selection

std::vector<int> Slic3r::GUI::UVEditorCanvas::m_selection

private

Referenced by is_selected(), on_mouse(), selected_islands(), set_islands(), and update_status().

m_snap_enabled

bool Slic3r::GUI::UVEditorCanvas::m_snap_enabled = false

private

Referenced by run_command(), set_snap_enabled(), snap_correction(), snap_enabled(), and update_status().

m_stencil_bits

int Slic3r::GUI::UVEditorCanvas::m_stencil_bits = -1

private

Referenced by render().

m_stroke_glmodel

GLModel Slic3r::GUI::UVEditorCanvas::m_stroke_glmodel

private

Referenced by render().

m_tile_enabled

bool Slic3r::GUI::UVEditorCanvas::m_tile_enabled = true

private

Referenced by framed_bounds(), rebuild_background_quad(), render(), and set_uv_transform().

m_tile_mirrored

bool Slic3r::GUI::UVEditorCanvas::m_tile_mirrored = false

private

Referenced by render(), and set_uv_transform().

m_tile_outline_glmodel

GLModel Slic3r::GUI::UVEditorCanvas::m_tile_outline_glmodel

private

Referenced by render().

m_tiling_scale

float Slic3r::GUI::UVEditorCanvas::m_tiling_scale = 1.f

private

Referenced by set_uv_transform(), and uv_delta_to_unwrap().

m_transforms

std::vector<IslandTransform> Slic3r::GUI::UVEditorCanvas::m_transforms

private

Referenced by island_at(), island_rotation_deg(), island_uv(), move_vertex_raw(), render(), and set_island_transforms().

m_vertex_edit_moved

bool Slic3r::GUI::UVEditorCanvas::m_vertex_edit_moved = false

private

Referenced by cancel_gesture(), end_gesture(), and on_mouse().

m_vertex_marker_glmodel

GLModel Slic3r::GUI::UVEditorCanvas::m_vertex_marker_glmodel

private

Referenced by render().

m_zoom

float Slic3r::GUI::UVEditorCanvas::m_zoom = 0.75f

private

Referenced by edge_at(), fit_view_to_content(), on_mouse(), rebuild_grid(), rebuild_rotation_dial(), render(), snap_correction(), vertex_at(), and view_half_extents().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/UVEditorCanvas.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/UVEditorCanvas.cpp