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

Inheritance diagram for Slic3r::GUI::UVEditorPanel:

Collaboration diagram for Slic3r::GUI::UVEditorPanel:

Public Member Functions
	UVEditorPanel (wxWindow *parent)
UVEditorCanvas *	canvas ()

Private Member Functions
void	on_tool (wxCommandEvent &evt)
void	apply_state (const UVEditorCanvas::PaneState &state)
void	refresh_selection_tools ()

Private Attributes
UVEditorCanvas *	m_canvas = nullptr
UVToolButton *	m_thumb = nullptr
wxStaticText *	m_layer_name = nullptr
wxStaticText *	m_tile = nullptr
UVToolButton *	m_background [3] {}
UVToolButton *	m_unwrap = nullptr
::SpinInput *	m_seam_angle = nullptr
::CheckBox *	m_connect = nullptr
UVToolButton *	m_select [3] {}
UVToolButton *	m_mark_seams = nullptr
UVToolButton *	m_seam_path = nullptr
UVToolButton *	m_clear_seams = nullptr
UVToolButton *	m_avg_scale = nullptr
UVToolButton *	m_cut = nullptr
UVToolButton *	m_join = nullptr
UVToolButton *	m_unjoin = nullptr
UVToolButton *	m_clear_edits = nullptr
UVToolButton *	m_snap = nullptr
UVToolButton *	m_frame = nullptr
wxStaticText *	m_status = nullptr
wxStaticText *	m_stats = nullptr

Detailed Description

Constructor & Destructor Documentation

◆ UVEditorPanel()

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

explicit

                                             : wxPanel(parent, wxID_ANY)
{
    const PaneColors c   = PaneColors::current();
    const int        gap = FromDIP(6);
    const int        pad = FromDIP(8);
    SetBackgroundColour(c.bg);
 
    const auto rule = [&](const wxSize &size) {
        auto *w = new wxWindow(this, wxID_ANY, wxDefaultPosition, size);
        w->SetBackgroundColour(c.rule);
        w->SetMinSize(size);
        return w;
    };
    const auto text = [&](const wxString &label, const wxColour &colour, long style = 0) {
        auto *t = new wxStaticText(this, wxID_ANY, label, wxDefaultPosition, wxDefaultSize, style);
        t->SetForegroundColour(colour);
        t->SetBackgroundColour(c.bg);
        return t;
    };
 
    // ---- header: the layer being edited, the background under the islands, and Unwrap ----
    auto *header = new wxBoxSizer(wxHORIZONTAL);
    m_thumb      = new UVToolButton(this, ID_UV_PICK_TEXTURE, std::string(), wxEmptyString,
                                    _L("Change texture - choose another one from the texture library"), false, false, 26);
    m_layer_name = text(wxEmptyString, c.ink, wxST_ELLIPSIZE_END);
    {
        wxFont font = m_layer_name->GetFont();
        font.MakeBold();
        m_layer_name->SetFont(font);
    }
    // The name opens the library too, like the texture's name in the layer card.
    m_layer_name->SetCursor(wxCursor(wxCURSOR_HAND));
    m_layer_name->SetToolTip(m_thumb->GetToolTipText());
    m_layer_name->Bind(wxEVT_LEFT_UP, [this](wxMouseEvent &) {
        if (m_canvas->pane_state().has_layer)
            m_canvas->run_command(UVEditorCanvas::Command::PickTexture);
    });
    m_layer_name->SetMinSize(wxSize(FromDIP(30), -1));
    m_tile = text(wxEmptyString, c.dim);
    m_tile->SetToolTip(_L("The active layer's tile size: how much of the model one repeat of the texture covers. The "
                          "canvas is measured in tiles, so one grid cell is one repeat. Change it with Tile size in "
                          "the layer's settings."));
    header->Add(m_thumb, 0, wxALIGN_CENTER_VERTICAL);
    header->Add(m_layer_name, 1, wxALIGN_CENTER_VERTICAL | wxLEFT, gap);
    header->Add(m_tile, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, gap);
 
    const char *const bg_icons[3] = { "texture_displacement_uv_bg_height", "texture_displacement_checker",
                                      "texture_displacement_distortion" };
    const wxString    bg_tips[3]  = { _L("Height map - show the layer's texture under the islands"),
                                      _L("Checker - a test grid; squares stay square where the unwrap does not stretch"),
                                      _L("Distortion - color each island by how much the unwrap stretches it") };
    for (int i = 0; i < 3; ++i) {
        m_background[i] = new UVToolButton(this, ID_UV_BG_HEIGHT + i, bg_icons[i], wxEmptyString, bg_tips[i], true, false, 22);
        header->Add(m_background[i], 0, wxALIGN_CENTER_VERTICAL | wxLEFT, i == 0 ? gap : FromDIP(3));
    }
    header->Add(rule(wxSize(1, FromDIP(18))), 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT, gap);
    m_unwrap = new UVToolButton(this, ID_UV_UNWRAP, "texture_displacement_map_unwrap", _L("Unwrap"), wxEmptyString, false, true, 24);
    header->Add(m_unwrap, 0, wxALIGN_CENTER_VERTICAL);
 
    // ---- settings: what the next Unwrap will do ----
    auto *settings = new wxBoxSizer(wxHORIZONTAL);
    auto *seam_label = text(_L("Seam angle"), c.dim);
    m_seam_angle = new ::SpinInput(this, wxEmptyString, wxString::FromUTF8("°"), wxDefaultPosition, wxSize(FromDIP(76), FromDIP(24)), 0,
                                   5, 90, 40);
    const wxString seam_tip = _L("Edges sharper than this are cut, and the pieces either side of them are flattened separately. "
                                 "Lower it to cut more: each piece then lies flat with less stretching, at the cost of the "
                                 "texture not running continuously across the cut. Takes effect at the next Unwrap.");
    seam_label->SetToolTip(seam_tip);
    m_seam_angle->SetToolTip(seam_tip);
    m_connect            = new ::CheckBox(this);
    auto *connect_label  = text(_L("Connect islands"), c.ink);
    const wxString connect_tip = _L("Lay the unwrap out as a connected net: pieces that share an edge are unfolded next to each "
                                    "other (a cube becomes a joined net rather than six loose squares). They stay separate "
                                    "islands, so you can still move any of them by hand afterwards.");
    m_connect->SetToolTip(connect_tip);
    connect_label->SetToolTip(connect_tip);
    settings->Add(seam_label, 0, wxALIGN_CENTER_VERTICAL);
    settings->Add(m_seam_angle, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, gap);
    settings->AddStretchSpacer();
    settings->Add(m_connect, 0, wxALIGN_CENTER_VERTICAL);
    settings->Add(connect_label, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(4));
 
    // ---- tool strip ----
    auto      *strip = new wxBoxSizer(wxVERTICAL);
    const auto tool  = [&](int id, const char *icon, const wxString &tip, bool toggle) {
        auto *b = new UVToolButton(this, id, icon, wxEmptyString, tip, toggle);
        strip->Add(b, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, FromDIP(4));
        return b;
    };
    // 11 px either side of a group rule (7 below plus the next button's own 4), against 4 px between buttons.
    const auto strip_rule = [&]() {
        auto *r = rule(wxSize(FromDIP(20), 1));
        strip->Add(r, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, FromDIP(11));
        strip->AddSpacer(FromDIP(7));
    };
    m_select[0] = tool(ID_UV_SELECT_ISLAND, "texture_displacement_uv_select_island",
                       _L("Island - work on whole islands. Click one to select it, then drag to move it, right-drag to "
                          "rotate it, or press R to rotate and S to scale with the mouse (click or Enter to confirm, Esc "
                          "to cancel)."),
                       true);
    m_select[1] = tool(ID_UV_SELECT_VERTEX, "texture_displacement_uv_select_vertex",
                       _L("Vertex - drag vertices to reshape an island by hand; Shift adds to the selection, Ctrl "
                          "toggles one in or out of it."),
                       true);
    m_select[2] = tool(ID_UV_SELECT_EDGE, "texture_displacement_uv_select_edge",
                       _L("Edge - drag edges to reshape an island by hand; Shift adds to the selection, Ctrl toggles "
                          "one in or out of it."),
                       true);
    strip_rule();
    m_mark_seams = tool(ID_UV_MARK_SEAMS, "texture_displacement_uv_seam",
                        _L("Mark seams - click edges on the model to cut the unwrap along them. The edge under the cursor is "
                           "highlighted yellow; click to mark it red, click a red edge again to unmark it. Painting is paused "
                           "while this is on."),
                        true);
    m_seam_path = tool(ID_UV_SEAM_PATH, "texture_displacement_uv_path",
                       _L("Path - instead of clicking every edge, click a start point and then an end point: the whole "
                          "shortest path between them is seamed at once. Available while marking seams."),
                       true);
    m_clear_seams = tool(ID_UV_CLEAR_SEAMS, "texture_displacement_cross", _L("Clear seams - remove every seam marked on this layer"), false);
    strip_rule();
    m_avg_scale = tool(ID_UV_AVG_SCALE, "texture_displacement_uv_avg_scale", _L("Average scale - give every island the same texel density"), false);
    m_cut       = tool(ID_UV_CUT, "texture_displacement_uv_cut", _L("Cut - split the selected island across its long axis"), false);
    m_join      = tool(ID_UV_JOIN, "texture_displacement_uv_join", _L("Join - unfold the selected island onto its nearest neighbour along their shared edge"), false);
    m_unjoin    = tool(ID_UV_UNJOIN, "texture_displacement_uv_unjoin", _L("Unjoin - send the selected island back to its own packed position"), false);
    strip->AddStretchSpacer();
    m_clear_edits = tool(ID_UV_CLEAR_EDITS, "texture_displacement_uv_clear_edits",
                         _L("Clear UV edits - discard all manual vertex/edge moves and return the unwrap to its automatic shape"), false);
    m_snap  = tool(ID_UV_SNAP, "texture_displacement_uv_snap", _L("Snap - stick islands together when dragging one against another"), true);
    m_frame = tool(ID_UV_FRAME, "texture_displacement_uv_frame",
                   _L("Frame all islands, fitting every one of them in view (Home or F).\n"
                      "Elsewhere on the canvas: scroll to zoom around the cursor, and middle-drag - or drag empty space - "
                      "to pan."),
                   false);
    strip->AddSpacer(FromDIP(4));
 
    m_canvas   = new UVEditorCanvas(this);
    auto *body = new wxBoxSizer(wxHORIZONTAL);
    body->Add(strip, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(4));
    body->Add(rule(wxSize(1, -1)), 0, wxEXPAND);
    body->Add(m_canvas, 1, wxEXPAND);
 
    // ---- status line: the current gesture on the left, the unwrap summary on the right ----
    m_status = text(wxEmptyString, c.dim, wxST_ELLIPSIZE_END);
    m_status->SetToolTip(_L("What is selected, and the exact figures of the move, rotation or scale while you drag one."));
    m_status->SetMinSize(wxSize(FromDIP(40), -1));
    m_stats      = text(wxEmptyString, c.dim);
    auto *status = new wxBoxSizer(wxHORIZONTAL);
    status->Add(m_status, 1, wxALIGN_CENTER_VERTICAL);
    status->Add(m_stats, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, gap);
 
    auto *sizer = new wxBoxSizer(wxVERTICAL);
    sizer->Add(header, 0, wxEXPAND | wxLEFT | wxRIGHT | wxTOP, pad);
    sizer->Add(settings, 0, wxEXPAND | wxLEFT | wxRIGHT | wxTOP, gap);
    sizer->Add(rule(wxSize(-1, 1)), 0, wxEXPAND | wxTOP, gap);
    sizer->Add(body, 1, wxEXPAND);
    sizer->Add(rule(wxSize(-1, 1)), 0, wxEXPAND);
    sizer->Add(status, 0, wxEXPAND | wxLEFT | wxRIGHT | wxTOP | wxBOTTOM, FromDIP(5));
    SetSizer(sizer);
 
    Bind(wxEVT_BUTTON, &UVEditorPanel::on_tool, this);
    // Both settings compare against the last state the gizmo pushed before sending anything: apply_state()
    // writes them back, and without the check that write would bounce straight back to the gizmo as an edit.
    m_seam_angle->Bind(wxEVT_SPINCTRL, [this](wxCommandEvent &) {
        const int value = m_seam_angle->GetValue();
        if (value != int(std::lround(m_canvas->pane_state().seam_angle_deg)))
            m_canvas->run_command(UVEditorCanvas::Command::SetSeamAngle, float(value));
    });
    const auto send_connect = [this]() {
        if (m_connect->GetValue() != m_canvas->pane_state().connect_islands)
            m_canvas->run_command(UVEditorCanvas::Command::SetConnectIslands, m_connect->GetValue() ? 1.f : 0.f);
    };
    m_connect->Bind(wxEVT_TOGGLEBUTTON, [send_connect](wxCommandEvent &e) {
        send_connect();
        e.Skip();
    });
    connect_label->Bind(wxEVT_LEFT_DOWN, [this, send_connect](wxMouseEvent &) {
        if (!m_connect->IsEnabled())
            return;
        m_connect->SetValue(!m_connect->GetValue());
        send_connect();
    });
 
    m_canvas->set_status_callback([this](const wxString &label) {
        if (m_status != nullptr && m_status->GetLabel() != label) {
            m_status->SetLabel(label);
            m_status->Refresh();
            refresh_selection_tools(); // a selection or mode change is what changes the status line
        }
    });
    m_canvas->set_pane_state_callback([this](const UVEditorCanvas::PaneState &state) { apply_state(state); });
    apply_state(m_canvas->pane_state());
 
    // AUI shows and hides the pane through this panel. Rebuild the canvas's GPU objects when it comes back, so
    // the texture and islands never depend on surviving the canvas's native window being hidden.
    Bind(wxEVT_SHOW, [this](wxShowEvent &e) {
        e.Skip();
        if (e.IsShown())
            m_canvas->invalidate_gl();
    });
}

References _L, apply_state(), m_avg_scale, m_background, m_canvas, m_clear_edits, m_clear_seams, m_connect, m_cut, m_frame, m_join, m_layer_name, m_mark_seams, m_seam_angle, m_seam_path, m_select, m_snap, m_stats, m_status, m_thumb, m_tile, m_unjoin, m_unwrap, on_tool(), Slic3r::GUI::UVEditorCanvas::PickTexture, refresh_selection_tools(), Slic3r::GUI::UVEditorCanvas::SetConnectIslands, Slic3r::GUI::UVEditorCanvas::SetSeamAngle, style, Slic3r::GUI::wxMouseEvent, and wxStaticText.

Here is the call graph for this function:

Member Function Documentation

◆ apply_state()

void Slic3r::GUI::UVEditorPanel::apply_state ( const UVEditorCanvas::PaneState & state )

private

{
    const wxString name = s.has_layer ? s.layer_name : _L("No layer mapped with Unwrap");
    const wxString tile = s.has_layer ? wxString::Format(_L("%.1f mm tile"), s.tile_mm) : wxString();
    const bool     relayout = m_layer_name->GetLabel() != name || m_tile->GetLabel() != tile;
    m_layer_name->SetLabel(name);
    m_tile->SetLabel(tile);
 
    if (s.thumbnail_px > 0 && s.thumbnail_rgb.size() == size_t(s.thumbnail_px) * size_t(s.thumbnail_px) * 3) {
        // Scaled to device pixels and tagged with the content scale, so HiDPI screens get every pixel of it.
        const double scale = GetContentScaleFactor();
        const int    px    = std::max(1, int(std::lround(FromDIP(20) * scale)));
        wxImage      image(s.thumbnail_px, s.thumbnail_px, false);
        std::copy(s.thumbnail_rgb.begin(), s.thumbnail_rgb.end(), image.GetData());
        m_thumb->SetBitmap(wxBitmap(image.Scale(px, px, wxIMAGE_QUALITY_HIGH), -1, scale));
    } else {
        m_thumb->SetBitmap(wxNullBitmap);
    }
    // Every tool that cannot be used right now is faded with the reason appended to its tooltip, rather than
    // being hard-disabled (which would hide the tooltip too - see UVToolButton::SetUnavailable()).
    const wxString no_layer = s.has_layer ? wxString() :
                                            _L("The pane follows the active texture layer, and that layer has to be mapped "
                                               "with Unwrap (LSCM). Add a layer and set its Mapping to Unwrap.");
    m_thumb->SetUnavailable(no_layer);
    m_layer_name->SetToolTip(s.has_layer ? m_thumb->GetToolTipText() : no_layer);
 
    for (int i = 0; i < 3; ++i) {
        m_background[i]->SetValue(int(s.background) == i);
        m_background[i]->SetUnavailable(no_layer);
    }
    m_unwrap->SetUnavailable(no_layer);
    m_unwrap->SetBadge(s.unwrap_stale);
    m_unwrap->SetTip(s.unwrap_stale ?
                         _L("Out of date - the paint, the seams or the seam angle changed since this unwrap was made. "
                            "Press to unwrap again.") :
                         _L("Flatten the painted area into UV islands. It is computed only when you press this, not on "
                            "every edit - so paint, change the seam angle or mark seams first, then press Unwrap."));
 
    if (m_seam_angle->GetValue() != int(std::lround(s.seam_angle_deg)))
        m_seam_angle->SetValue(int(std::lround(s.seam_angle_deg)));
    m_seam_angle->Enable(s.has_layer);
    m_connect->SetValue(s.connect_islands);
    m_connect->Enable(s.has_layer);
 
    m_mark_seams->SetValue(s.mark_seams);
    m_mark_seams->SetUnavailable(no_layer);
    m_seam_path->SetValue(s.seam_path);
    m_seam_path->SetUnavailable(!no_layer.empty() ? no_layer :
                                s.mark_seams     ? wxString() :
                                                   _L("Turn Mark seams on first - Path is a quicker way of marking them."));
    m_clear_seams->SetUnavailable(!no_layer.empty() ? no_layer :
                                  s.has_seams      ? wxString() :
                                                     _L("No seams are marked on this layer."));
    m_clear_edits->SetUnavailable(!no_layer.empty() ? no_layer :
                                  s.has_uv_edits   ? wxString() :
                                                     _L("No islands have been reshaped by hand, so there is nothing to "
                                                        "discard."));
 
    m_stats->SetLabel(s.unwrapped ? wxString::Format(_L_PLURAL("%d island", "%d islands", s.island_count), s.island_count) + ", " +
                                        wxString::Format(_L_PLURAL("%s face", "%s faces", s.face_count),
                                                         wxString(std::to_string(s.face_count))) :
                                    wxString());
    m_stats->SetToolTip(s.unwrapped ? _L("How the painted area came out of the unwrap: the number of separate pieces it "
                                         "was cut into (at the seams and at edges sharper than the seam angle), and how "
                                         "many triangles they hold in total.") :
                                      wxString());
    refresh_selection_tools();
    if (relayout)
        Layout();
}

Referenced by UVEditorPanel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ canvas()

UVEditorCanvas * Slic3r::GUI::UVEditorPanel::canvas ( )

inline

423{ return m_canvas; }

References m_canvas.

◆ on_tool()

void Slic3r::GUI::UVEditorPanel::on_tool ( wxCommandEvent & evt )

private

{
    using Command = UVEditorCanvas::Command;
    const int  id = evt.GetId();
    const bool on = evt.GetInt() != 0;
    switch (id) {
    case ID_UV_FRAME:       m_canvas->run_command(Command::FrameAll); break;
    case ID_UV_SNAP:        m_canvas->run_command(Command::ToggleSnap); break;
    case ID_UV_AVG_SCALE:   m_canvas->run_command(Command::AverageScale); break;
    case ID_UV_CUT:         m_canvas->run_command(Command::CutSelectedIsland); break;
    case ID_UV_JOIN:        m_canvas->run_command(Command::JoinSelected); break;
    case ID_UV_UNJOIN:      m_canvas->run_command(Command::UnjoinSelected); break;
    case ID_UV_UNWRAP:      m_canvas->run_command(Command::Unwrap); break;
    case ID_UV_MARK_SEAMS:  m_canvas->run_command(Command::SetMarkSeams, on ? 1.f : 0.f); break;
    case ID_UV_SEAM_PATH:   m_canvas->run_command(Command::SetSeamPath, on ? 1.f : 0.f); break;
    case ID_UV_CLEAR_SEAMS: m_canvas->run_command(Command::ClearSeams); break;
    case ID_UV_CLEAR_EDITS: m_canvas->run_command(Command::ClearUVEdits); break;
    case ID_UV_PICK_TEXTURE: m_canvas->run_command(Command::PickTexture); break;
    case ID_UV_SELECT_ISLAND:
    case ID_UV_SELECT_VERTEX:
    case ID_UV_SELECT_EDGE: m_canvas->run_command(Command::SetSelectMode, float(id - ID_UV_SELECT_ISLAND)); break;
    case ID_UV_BG_HEIGHT:
    case ID_UV_BG_CHECKER:
    case ID_UV_BG_DISTORTION:
        // Shown straight away; the gizmo confirms it with its next state push.
        for (int i = 0; i < 3; ++i)
            m_background[i]->SetValue(i == id - ID_UV_BG_HEIGHT);
        m_canvas->run_command(Command::SetBackground, float(id - ID_UV_BG_HEIGHT));
        break;
    default: evt.Skip(); return;
    }
    refresh_selection_tools();
}

References Slic3r::GUI::Command, m_background, m_canvas, and refresh_selection_tools().

Referenced by UVEditorPanel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ refresh_selection_tools()

void Slic3r::GUI::UVEditorPanel::refresh_selection_tools ( )

private

{
    const bool has_islands = m_canvas->has_islands();
    const int  mode        = int(m_canvas->select_mode());
    // Faded rather than hard-disabled, so the tooltip still says what is missing (see apply_state()).
    const wxString not_unwrapped = has_islands ? wxString() : _L("Press Unwrap first - there are no islands to work on yet.");
    for (int i = 0; i < 3; ++i) {
        m_select[i]->SetValue(i == mode);
        m_select[i]->SetUnavailable(not_unwrapped);
    }
    const bool island_picked = has_islands && m_canvas->select_mode() == UVEditorCanvas::SelectMode::Island &&
                               m_canvas->selected_island() >= 0;
    const wxString no_island = !not_unwrapped.empty() ? not_unwrapped :
                               island_picked          ? wxString() :
                                                        _L("Click an island on the canvas first, in Island mode.");
    m_avg_scale->SetUnavailable(not_unwrapped);
    m_cut->SetUnavailable(no_island);
    m_join->SetUnavailable(no_island);
    m_unjoin->SetUnavailable(no_island);
    m_snap->SetUnavailable(not_unwrapped);
    m_snap->SetValue(m_canvas->snap_enabled());
    m_frame->SetUnavailable(not_unwrapped);
}