Slic3r::GUI::TexturePreviewCanvas Class Reference

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

Inheritance diagram for Slic3r::GUI::TexturePreviewCanvas:

Collaboration diagram for Slic3r::GUI::TexturePreviewCanvas:

Public Types
enum class	RenderMode { Original , MultiColor , FilamentMap }

Public Member Functions
	TexturePreviewCanvas (wxWindow *parent, const wxGLAttributes &attrs)
	~TexturePreviewCanvas ()
void	set_mesh_data (const std::vector< std::array< float, 3 > > &vertices, const std::vector< std::array< int, 3 > > &indices)
void	set_texture_data (const std::vector< std::array< float, 2 > > &uvs, const unsigned char *tex_data, int tex_w, int tex_h, int tex_channels)
void	set_texture_render_data (const std::vector< std::vector< unsigned char > > &tex_pixels_rgb, const std::vector< int > &tex_widths, const std::vector< int > &tex_heights, const std::vector< std::array< std::array< float, 2 >, 3 > > &face_uvs, const std::vector< int > &face_tex_ids)
void	set_painted_mesh_data (const std::vector< std::array< float, 3 > > &vertices, const std::vector< std::array< int, 3 > > &indices)
void	set_face_colors (const std::vector< std::array< std::size_t, 3 > > &face_colors)
void	set_original_face_colors (const std::vector< std::array< std::size_t, 3 > > &face_colors)
void	set_filament_color_map (const std::map< std::array< std::size_t, 3 >, std::array< float, 3 > > &color_map)
void	set_render_mode (RenderMode mode)
RenderMode	get_render_mode () const
void	set_computing_overlay (bool show)
void	reset_view ()

Private Types
enum class	DragMode { None , Rotate , Pan }

Private Member Functions
void	on_paint (wxPaintEvent &evt)
void	on_size (wxSizeEvent &evt)
void	on_mouse (wxMouseEvent &evt)
void	ensure_gl_ready ()
void	render ()
void	render_mesh ()
void	render_textured_original ()
void	render_reset_overlay (const wxSize &logical_size, const wxSize &viewport_size)
void	upload_reset_icon_textures ()
unsigned int	upload_reset_icon_texture (const std::string &icon_name)
wxRect	reset_overlay_rect () const
bool	handle_reset_overlay_mouse (wxMouseEvent &evt)
void	upload_textures ()
void	compute_smooth_normals ()
void	update_bounding_box ()

Private Attributes
wxGLContext *	m_context = nullptr
bool	m_gl_initialized = false
RenderMode	m_mode = RenderMode::Original
float	m_zoom = 1.0f
float	m_rot_x = -30.0f
float	m_rot_y = 30.0f
float	m_pan_x = 0.0f
float	m_pan_y = 0.0f
wxPoint	m_last_mouse_pos
DragMode	m_drag_mode = DragMode::None
std::vector< std::array< float, 3 > >	m_vertices
std::vector< std::array< int, 3 > >	m_indices
std::vector< std::array< float, 2 > >	m_uvs
std::vector< std::array< float, 3 > >	m_painted_vertices
std::vector< std::array< int, 3 > >	m_painted_indices
std::vector< std::array< float, 3 > >	m_face_colors_rgb
std::vector< std::array< float, 3 > >	m_original_face_colors_rgb
std::vector< std::array< float, 3 > >	m_filament_colors_rgb
std::map< std::array< std::size_t, 3 >, std::array< float, 3 > >	m_color_map
unsigned int	m_tex_id = 0
int	m_tex_w = 0
int	m_tex_h = 0
int	m_tex_channels = 3
bool	m_tex_dirty = false
std::vector< unsigned char >	m_tex_data
std::vector< unsigned int >	m_gl_tex_ids
std::vector< std::vector< unsigned char > >	m_tex_pixels_rgb
std::vector< int >	m_tex_widths
std::vector< int >	m_tex_heights
std::vector< std::array< std::array< float, 2 >, 3 > >	m_face_uvs
std::vector< int >	m_face_tex_ids
bool	m_multi_tex_dirty = false
std::vector< std::array< float, 3 > >	m_vertex_normals
std::array< float, 3 >	m_center = {0, 0, 0}
float	m_radius = 1.0f
unsigned int	m_reset_icon_tex = 0
unsigned int	m_reset_icon_hover_tex = 0
unsigned int	m_reset_icon_dark_tex = 0
unsigned int	m_reset_icon_dark_hover_tex = 0
bool	m_reset_overlay_hovered = false
bool	m_reset_overlay_pressed = false

Detailed Description

Member Enumeration Documentation

DragMode

enum class Slic3r::GUI::TexturePreviewCanvas::DragMode

strongprivate

Enumerator
None
Rotate
Pan

{ None, Rotate, Pan };

RenderMode

enum class Slic3r::GUI::TexturePreviewCanvas::RenderMode

strong

Enumerator
Original
MultiColor
FilamentMap

{ Original, MultiColor, FilamentMap };

Constructor & Destructor Documentation

TexturePreviewCanvas()

Slic3r::GUI::TexturePreviewCanvas::TexturePreviewCanvas	(	wxWindow *	parent,
		const wxGLAttributes &	attrs )

    : wxGLCanvas(parent, attrs, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxFULL_REPAINT_ON_RESIZE)
{
    m_context = new wxGLContext(this);
 
    Bind(wxEVT_PAINT, &TexturePreviewCanvas::on_paint, this);
    Bind(wxEVT_SIZE,  &TexturePreviewCanvas::on_size,  this);
    Bind(wxEVT_MOUSEWHEEL,  &TexturePreviewCanvas::on_mouse, this);
    Bind(wxEVT_LEFT_DOWN,   &TexturePreviewCanvas::on_mouse, this);
    Bind(wxEVT_LEFT_UP,     &TexturePreviewCanvas::on_mouse, this);
    Bind(wxEVT_RIGHT_DOWN,  &TexturePreviewCanvas::on_mouse, this);
    Bind(wxEVT_RIGHT_UP,    &TexturePreviewCanvas::on_mouse, this);
    Bind(wxEVT_MIDDLE_DOWN, &TexturePreviewCanvas::on_mouse, this);
    Bind(wxEVT_MIDDLE_UP,   &TexturePreviewCanvas::on_mouse, this);
    Bind(wxEVT_MOTION,      &TexturePreviewCanvas::on_mouse, this);
    Bind(wxEVT_MOUSE_CAPTURE_LOST, [this](wxMouseCaptureLostEvent&) {
        m_drag_mode = DragMode::None;
        m_reset_overlay_pressed = false;
    });
    Bind(wxEVT_LEAVE_WINDOW, &TexturePreviewCanvas::on_mouse, this);
}

References m_context, m_drag_mode, m_reset_overlay_pressed, None, on_mouse(), on_paint(), and on_size().

Here is the call graph for this function:

~TexturePreviewCanvas()

Slic3r::GUI::TexturePreviewCanvas::~TexturePreviewCanvas

(

)

{
    // See MixedFilamentDialog::~MixedFilamentDialog: a widget destroyed while it
    // still holds the capture wedges mouse input for the whole application.
    if (HasCapture())
        ReleaseMouse();
 
    if (m_context) {
        SetCurrent(*m_context);
        if (m_tex_id)
            glDeleteTextures(1, &m_tex_id);
        for (unsigned int id : m_gl_tex_ids)
            if (id) glDeleteTextures(1, &id);
        for (unsigned int id : {m_reset_icon_tex, m_reset_icon_hover_tex,
                                m_reset_icon_dark_tex, m_reset_icon_dark_hover_tex})
            if (id) glDeleteTextures(1, &id);
        delete m_context;
    }
}

References glDeleteTextures, m_context, m_gl_tex_ids, m_reset_icon_dark_hover_tex, m_reset_icon_dark_tex, m_reset_icon_hover_tex, m_reset_icon_tex, and m_tex_id.

Member Function Documentation

compute_smooth_normals()

void Slic3r::GUI::TexturePreviewCanvas::compute_smooth_normals ( )

private

{
    m_vertex_normals.clear();
    if (m_vertices.empty() || m_indices.empty()) return;
 
    m_vertex_normals.resize(m_vertices.size(), {0.f, 0.f, 0.f});
 
    for (const auto& face : m_indices) {
        int i0 = face[0], i1 = face[1], i2 = face[2];
        if (i0 < 0 || i0 >= (int)m_vertices.size() ||
            i1 < 0 || i1 >= (int)m_vertices.size() ||
            i2 < 0 || i2 >= (int)m_vertices.size())
            continue;
 
        const auto& v0 = m_vertices[i0];
        const auto& v1 = m_vertices[i1];
        const auto& v2 = m_vertices[i2];
 
        float nx = (v1[1]-v0[1])*(v2[2]-v0[2]) - (v1[2]-v0[2])*(v2[1]-v0[1]);
        float ny = (v1[2]-v0[2])*(v2[0]-v0[0]) - (v1[0]-v0[0])*(v2[2]-v0[2]);
        float nz = (v1[0]-v0[0])*(v2[1]-v0[1]) - (v1[1]-v0[1])*(v2[0]-v0[0]);
 
        m_vertex_normals[i0][0] += nx; m_vertex_normals[i0][1] += ny; m_vertex_normals[i0][2] += nz;
        m_vertex_normals[i1][0] += nx; m_vertex_normals[i1][1] += ny; m_vertex_normals[i1][2] += nz;
        m_vertex_normals[i2][0] += nx; m_vertex_normals[i2][1] += ny; m_vertex_normals[i2][2] += nz;
    }
 
    for (auto& n : m_vertex_normals) {
        float len = std::sqrt(n[0]*n[0] + n[1]*n[1] + n[2]*n[2]);
        if (len > 1e-8f) { n[0] /= len; n[1] /= len; n[2] /= len; }
    }
}

References m_indices, m_vertex_normals, and m_vertices.

Referenced by set_mesh_data().

Here is the caller graph for this function:

ensure_gl_ready()

void Slic3r::GUI::TexturePreviewCanvas::ensure_gl_ready ( )

private

{
    if (m_gl_initialized) return;
 
    // BBS loads the GL entry points here with GLEW; Orca loads them centrally in
    // OpenGLManager, so only check that this has already happened (glad leaves unresolved
    // entry points null) and drain any stale error state.
    if (glGetString == nullptr) {
        BOOST_LOG_TRIVIAL(error) << "TexturePreviewCanvas: OpenGL functions are not loaded yet";
        return;
    }
    while (glGetError() != GL_NO_ERROR) {}
 
    m_gl_initialized = true;
 
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_COLOR_MATERIAL);
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
 
    GLfloat light_pos[]     = { 0.5f, 1.0f, 1.0f, 0.0f };
    GLfloat light_ambient[] = { 0.3f, 0.3f, 0.3f, 1.0f };
    GLfloat light_diffuse[] = { 0.8f, 0.8f, 0.8f, 1.0f };
    glLightfv(GL_LIGHT0, GL_POSITION, light_pos);
    glLightfv(GL_LIGHT0, GL_AMBIENT,  light_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE,  light_diffuse);
}

References GL_AMBIENT, GL_AMBIENT_AND_DIFFUSE, GL_COLOR_MATERIAL, GL_DEPTH_TEST, GL_DIFFUSE, GL_FRONT_AND_BACK, GL_LIGHT0, GL_LIGHTING, GL_NO_ERROR, GL_POSITION, glColorMaterial, glEnable, glGetError, glGetString, glLightfv, and m_gl_initialized.

Referenced by on_paint().

Here is the caller graph for this function:

get_render_mode()

RenderMode Slic3r::GUI::TexturePreviewCanvas::get_render_mode ( ) const

inline

{ return m_mode; }

References m_mode.

handle_reset_overlay_mouse()

bool Slic3r::GUI::TexturePreviewCanvas::handle_reset_overlay_mouse ( wxMouseEvent & evt )

private

{
    if (evt.Leaving()) {
        if (m_reset_overlay_pressed) {
            m_reset_overlay_hovered = false;
            m_reset_overlay_pressed = false;
            SetCursor(wxCursor(wxCURSOR_ARROW));
            if (HasCapture())
                ReleaseMouse();
            Refresh();
            return true;
        }
        if (m_reset_overlay_hovered) {
            m_reset_overlay_hovered = false;
            SetCursor(wxCursor(wxCURSOR_ARROW));
            Refresh();
        }
        return false;
    }
 
    const bool over = reset_overlay_rect().Contains(evt.GetPosition());
    if (over != m_reset_overlay_hovered) {
        m_reset_overlay_hovered = over;
        SetCursor(wxCursor(over ? wxCURSOR_HAND : wxCURSOR_ARROW));
        Refresh();
    }
 
    if (m_drag_mode != DragMode::None && !m_reset_overlay_pressed)
        return false;
 
    if (evt.LeftDown() && over) {
        m_reset_overlay_pressed = true;
        if (!HasCapture())
            CaptureMouse();
        Refresh();
        return true;
    }
 
    if (evt.LeftUp() && m_reset_overlay_pressed) {
        const bool activate = over;
        m_reset_overlay_pressed = false;
        if (HasCapture())
            ReleaseMouse();
        if (activate)
            reset_view();
        else
            Refresh();
        return true;
    }
 
    return over;
}

References m_drag_mode, m_reset_overlay_hovered, m_reset_overlay_pressed, None, reset_overlay_rect(), reset_view(), and Slic3r::GUI::wxMouseEvent.

Referenced by on_mouse().

Here is the call graph for this function:

Here is the caller graph for this function:

on_mouse()

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

private

{
    if (handle_reset_overlay_mouse(evt))
        return;
 
    if (evt.LeftDown()) {
        m_drag_mode = DragMode::Rotate;
        m_last_mouse_pos = evt.GetPosition();
        if (!HasCapture()) CaptureMouse();
    }
    else if (evt.LeftUp()) {
        if (m_drag_mode == DragMode::Rotate) {
            m_drag_mode = DragMode::None;
            if (HasCapture()) ReleaseMouse();
        }
    }
    else if (evt.RightDown()) {
        m_drag_mode = DragMode::Pan;
        m_last_mouse_pos = evt.GetPosition();
        if (!HasCapture()) CaptureMouse();
    }
    else if (evt.MiddleDown()) {
        m_drag_mode = DragMode::Pan;
        m_last_mouse_pos = evt.GetPosition();
        if (!HasCapture()) CaptureMouse();
    }
    else if (evt.RightUp() || evt.MiddleUp()) {
        if (m_drag_mode == DragMode::Pan) {
            m_drag_mode = DragMode::None;
            if (HasCapture()) ReleaseMouse();
        }
    }
    else if (evt.Dragging() && m_drag_mode != DragMode::None) {
        wxPoint pos = evt.GetPosition();
        float dx = (float)(pos.x - m_last_mouse_pos.x);
        float dy = (float)(pos.y - m_last_mouse_pos.y);
 
        if (m_drag_mode == DragMode::Rotate) {
            m_rot_y += dx * 0.5f;
            m_rot_x += dy * 0.5f;
            m_rot_x = std::max(-89.0f, std::min(89.0f, m_rot_x));
        } else if (m_drag_mode == DragMode::Pan) {
            wxSize sz = GetClientSize();
            if (sz.x > 0)
                m_pan_x += dx / (float)sz.x * m_radius * 2.0f / m_zoom;
            if (sz.y > 0)
                m_pan_y -= dy / (float)sz.y * m_radius * 2.0f / m_zoom;
        }
 
        m_last_mouse_pos = pos;
        Refresh();
    }
    else if (evt.GetWheelRotation() != 0) {
        float delta = evt.GetWheelRotation() > 0 ? 1.1f : 0.9f;
        m_zoom *= delta;
        m_zoom = std::max(0.1f, std::min(20.0f, m_zoom));
        Refresh();
    }
}

References handle_reset_overlay_mouse(), m_drag_mode, m_last_mouse_pos, m_pan_x, m_pan_y, m_radius, m_rot_x, m_rot_y, m_zoom, None, Pan, Rotate, and Slic3r::GUI::wxMouseEvent.

Referenced by TexturePreviewCanvas().

Here is the call graph for this function:

Here is the caller graph for this function:

on_paint()

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

private

{
    wxPaintDC dc(this);
    if (!m_context) return;
    SetCurrent(*m_context);
    ensure_gl_ready();
    render();
    SwapBuffers();
}

References ensure_gl_ready(), m_context, and render().

Referenced by TexturePreviewCanvas().

Here is the call graph for this function:

Here is the caller graph for this function:

on_size()

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

private

{
    Refresh();
}

Referenced by TexturePreviewCanvas().

Here is the caller graph for this function:

render()

void Slic3r::GUI::TexturePreviewCanvas::render ( )

private

{
    wxSize sz = GetClientSize();
    if (sz.x <= 0 || sz.y <= 0) return;
 
    wxSize viewport_sz = gl_viewport_size(this, sz);
    glViewport(0, 0, viewport_sz.x, viewport_sz.y);
    // Same palette key as the preview container, so canvas and frame cannot drift apart.
    const wxColour clear_clr = StateColor::darkModeColorFor(wxColour("#EEEEEE"));
    glClearColor(clear_clr.Red() / 255.f, clear_clr.Green() / 255.f, clear_clr.Blue() / 255.f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    float aspect = (float)viewport_sz.x / (float)viewport_sz.y;
    float dist = m_radius * 3.0f / m_zoom;
    float near_plane = dist * 0.01f;
    float far_plane  = dist * 10.0f;
    float fov_rad    = 45.0f * static_cast<float>(M_PI) / 180.0f;
    float f          = 1.0f / std::tan(fov_rad / 2.0f);
    float proj[16]   = {};
    proj[0]  = f / aspect;
    proj[5]  = f;
    proj[10] = (far_plane + near_plane) / (near_plane - far_plane);
    proj[11] = -1.0f;
    proj[14] = (2.0f * far_plane * near_plane) / (near_plane - far_plane);
    glMultMatrixf(proj);
 
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.0f, 0.0f, -dist);
    glTranslatef(m_pan_x, m_pan_y, 0.0f);
    glRotatef(m_rot_x, 1.0f, 0.0f, 0.0f);
    glRotatef(m_rot_y, 0.0f, 1.0f, 0.0f);
    glTranslatef(-m_center[0], -m_center[1], -m_center[2]);
 
    render_mesh();
    render_reset_overlay(sz, viewport_sz);
}

References StateColor::darkModeColorFor(), Slic3r::Geometry::dist(), Slic3r::f(), GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_MODELVIEW, GL_PROJECTION, gl_viewport_size(), glClear, glClearColor, glLoadIdentity, glMatrixMode, glMultMatrixf, glRotatef, glTranslatef, glViewport, m_center, m_pan_x, m_pan_y, M_PI, m_radius, m_rot_x, m_rot_y, m_zoom, render_mesh(), and render_reset_overlay().

Referenced by on_paint().

Here is the call graph for this function:

Here is the caller graph for this function:

render_mesh()

void Slic3r::GUI::TexturePreviewCanvas::render_mesh ( )

private

{
    if (m_vertices.empty() || m_indices.empty()) return;
 
    // Original mode with texture data: use proper texture mapping
    if (m_mode == RenderMode::Original && !m_face_uvs.empty()) {
        render_textured_original();
        return;
    }
 
    // For Multi-Color / FilamentMap, use the painted (remeshed) geometry if available;
    // the face color arrays match the painted mesh, not the original mesh.
    const bool use_painted = (m_mode != RenderMode::Original)
                             && !m_painted_vertices.empty()
                             && !m_painted_indices.empty();
 
    const auto& verts   = use_painted ? m_painted_vertices : m_vertices;
    const auto& faces   = use_painted ? m_painted_indices  : m_indices;
 
    const std::vector<std::array<float, 3>>* colors_ptr = nullptr;
    if (m_mode == RenderMode::Original && !m_original_face_colors_rgb.empty()
        && m_original_face_colors_rgb.size() == m_indices.size()) {
        colors_ptr = &m_original_face_colors_rgb;
    } else if (m_mode == RenderMode::FilamentMap && !m_filament_colors_rgb.empty()
               && m_filament_colors_rgb.size() == faces.size()) {
        colors_ptr = &m_filament_colors_rgb;
    } else if (!m_face_colors_rgb.empty() && m_face_colors_rgb.size() == faces.size()) {
        colors_ptr = &m_face_colors_rgb;
    }
 
    // Use smooth normals for the original mesh when available
    const bool has_smooth = !use_painted
                            && (m_vertex_normals.size() == m_vertices.size());
 
    glDisable(GL_TEXTURE_2D);
    glEnable(GL_LIGHTING);
 
    glBegin(GL_TRIANGLES);
    for (size_t fi = 0; fi < faces.size(); ++fi) {
        if (colors_ptr)
            glColor3fv((*colors_ptr)[fi].data());
        else
            glColor3f(0.7f, 0.7f, 0.7f);
 
        const auto& face = faces[fi];
        for (int vi = 0; vi < 3; ++vi) {
            int idx = face[vi];
            if (idx < 0 || idx >= (int)verts.size()) continue;
 
            if (has_smooth && idx < (int)m_vertex_normals.size()) {
                glNormal3fv(m_vertex_normals[idx].data());
            } else if (vi == 0) {
                const auto& v0 = verts[face[0]];
                const auto& v1 = verts[face[1]];
                const auto& v2 = verts[face[2]];
                float nx = (v1[1]-v0[1])*(v2[2]-v0[2]) - (v1[2]-v0[2])*(v2[1]-v0[1]);
                float ny = (v1[2]-v0[2])*(v2[0]-v0[0]) - (v1[0]-v0[0])*(v2[2]-v0[2]);
                float nz = (v1[0]-v0[0])*(v2[1]-v0[1]) - (v1[1]-v0[1])*(v2[0]-v0[0]);
                float len = std::sqrt(nx*nx + ny*ny + nz*nz);
                if (len > 1e-8f) { nx /= len; ny /= len; nz /= len; }
                glNormal3f(nx, ny, nz);
            }
 
            glVertex3fv(verts[idx].data());
        }
    }
    glEnd();
}

References FilamentMap, GL_LIGHTING, GL_TEXTURE_2D, GL_TRIANGLES, glBegin, glColor3f, glColor3fv, glDisable, glEnable, glEnd, glNormal3f, glNormal3fv, glVertex3fv, m_face_colors_rgb, m_face_uvs, m_filament_colors_rgb, m_indices, m_mode, m_original_face_colors_rgb, m_painted_indices, m_painted_vertices, m_vertex_normals, m_vertices, Original, and render_textured_original().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_reset_overlay()

void Slic3r::GUI::TexturePreviewCanvas::render_reset_overlay ( const wxSize & logical_size, const wxSize & viewport_size )

private

{
    if (logical_size.x <= 0 || logical_size.y <= 0 || viewport_size.x <= 0 || viewport_size.y <= 0)
        return;
 
    upload_reset_icon_textures();
 
    const unsigned int tex_id = is_dark()
        ? (m_reset_overlay_hovered ? m_reset_icon_dark_hover_tex : m_reset_icon_dark_tex)
        : (m_reset_overlay_hovered ? m_reset_icon_hover_tex : m_reset_icon_tex);
    if (!tex_id)
        return;
 
    wxRect rc = reset_overlay_rect();
    const float sx = (float)viewport_size.x / (float)logical_size.x;
    const float sy = (float)viewport_size.y / (float)logical_size.y;
    const float x0 = rc.GetLeft() * sx;
    const float y0 = rc.GetTop() * sy;
    const float x1 = (rc.GetLeft() + rc.GetWidth()) * sx;
    const float y1 = (rc.GetTop() + rc.GetHeight()) * sy;
    const float alpha = m_reset_overlay_hovered ? 1.0f : 0.78f;
 
    glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TEXTURE_BIT | GL_DEPTH_BUFFER_BIT);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_LIGHTING);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, tex_id);
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    glOrtho(0.0, viewport_size.x, viewport_size.y, 0.0, -1.0, 1.0);
 
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
 
    glColor4f(1.0f, 1.0f, 1.0f, alpha);
    glBegin(GL_QUADS);
        glTexCoord2f(0.0f, 0.0f); glVertex2f(x0, y0);
        glTexCoord2f(1.0f, 0.0f); glVertex2f(x1, y0);
        glTexCoord2f(1.0f, 1.0f); glVertex2f(x1, y1);
        glTexCoord2f(0.0f, 1.0f); glVertex2f(x0, y1);
    glEnd();
 
    glPopMatrix();
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
 
    glBindTexture(GL_TEXTURE_2D, 0);
    glPopAttrib();
}

References GL_BLEND, GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_DEPTH_TEST, GL_ENABLE_BIT, GL_LIGHTING, GL_MODELVIEW, GL_MODULATE, GL_ONE_MINUS_SRC_ALPHA, GL_PROJECTION, GL_QUADS, GL_SRC_ALPHA, GL_TEXTURE_2D, GL_TEXTURE_BIT, GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, glBegin, glBindTexture, glBlendFunc, glColor4f, glDisable, glEnable, glEnd, glLoadIdentity, glMatrixMode, glOrtho, glPopAttrib, glPopMatrix, glPushAttrib, glPushMatrix, glTexCoord2f, glTexEnvi, glVertex2f, is_dark(), m_reset_icon_dark_hover_tex, m_reset_icon_dark_tex, m_reset_icon_hover_tex, m_reset_icon_tex, m_reset_overlay_hovered, reset_overlay_rect(), and upload_reset_icon_textures().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_textured_original()

void Slic3r::GUI::TexturePreviewCanvas::render_textured_original ( )

private

{
    if (m_vertices.empty() || m_indices.empty()) return;
    if (m_face_uvs.empty() || m_face_tex_ids.empty()) return;
    if (m_face_uvs.size() != m_indices.size()) return;
 
    upload_textures();
 
    const bool has_smooth = (m_vertex_normals.size() == m_vertices.size());
 
    // Group faces by texture id for batch rendering
    std::map<int, std::vector<size_t>> tex_groups;
    for (size_t fi = 0; fi < m_indices.size(); ++fi) {
        int tid = (fi < m_face_tex_ids.size()) ? m_face_tex_ids[fi] : -1;
        tex_groups[tid].push_back(fi);
    }
 
    glEnable(GL_LIGHTING);
    glColor3f(1.0f, 1.0f, 1.0f);
 
    for (const auto& [tid, face_list] : tex_groups) {
        bool tex_bound = false;
        if (tid >= 0 && tid < (int)m_gl_tex_ids.size() && m_gl_tex_ids[tid] != 0) {
            glEnable(GL_TEXTURE_2D);
            glBindTexture(GL_TEXTURE_2D, m_gl_tex_ids[tid]);
            tex_bound = true;
        } else {
            glDisable(GL_TEXTURE_2D);
        }
 
        glBegin(GL_TRIANGLES);
        for (size_t fi : face_list) {
            const auto& face = m_indices[fi];
            const auto& uvs  = m_face_uvs[fi];
 
            if (!tex_bound) {
                if (fi < m_original_face_colors_rgb.size())
                    glColor3fv(m_original_face_colors_rgb[fi].data());
                else
                    glColor3f(0.7f, 0.7f, 0.7f);
            }
 
            for (int vi = 0; vi < 3; ++vi) {
                int idx = face[vi];
                if (idx < 0 || idx >= (int)m_vertices.size()) continue;
 
                if (has_smooth) {
                    glNormal3fv(m_vertex_normals[idx].data());
                } else if (vi == 0) {
                    const auto& v0 = m_vertices[face[0]];
                    const auto& v1 = m_vertices[face[1]];
                    const auto& v2 = m_vertices[face[2]];
                    float nx = (v1[1]-v0[1])*(v2[2]-v0[2]) - (v1[2]-v0[2])*(v2[1]-v0[1]);
                    float ny = (v1[2]-v0[2])*(v2[0]-v0[0]) - (v1[0]-v0[0])*(v2[2]-v0[2]);
                    float nz = (v1[0]-v0[0])*(v2[1]-v0[1]) - (v1[1]-v0[1])*(v2[0]-v0[0]);
                    float len = std::sqrt(nx*nx + ny*ny + nz*nz);
                    if (len > 1e-8f) { nx /= len; ny /= len; nz /= len; }
                    glNormal3f(nx, ny, nz);
                }
 
                if (tex_bound)
                    glTexCoord2fv(uvs[vi].data());
                glVertex3fv(m_vertices[idx].data());
            }
        }
        glEnd();
    }
 
    glDisable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, 0);
}

References GL_LIGHTING, GL_TEXTURE_2D, GL_TRIANGLES, glBegin, glBindTexture, glColor3f, glColor3fv, glDisable, glEnable, glEnd, glNormal3f, glNormal3fv, glTexCoord2fv, glVertex3fv, m_face_tex_ids, m_face_uvs, m_gl_tex_ids, m_indices, m_original_face_colors_rgb, m_vertex_normals, m_vertices, and upload_textures().

Referenced by render_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_overlay_rect()

wxRect Slic3r::GUI::TexturePreviewCanvas::reset_overlay_rect ( ) const

private

{
    wxSize sz = GetClientSize();
    const int button_size = FromDIP(40);
    const int margin = FromDIP(20);
    return wxRect(
        std::max(margin, sz.x - button_size - margin),
        std::max(margin, sz.y - button_size - margin),
        button_size,
        button_size);
}

Referenced by handle_reset_overlay_mouse(), and render_reset_overlay().

Here is the caller graph for this function:

reset_view()

void Slic3r::GUI::TexturePreviewCanvas::reset_view

(

)

{
    m_zoom  = 1.0f;
    m_rot_x = -30.0f;
    m_rot_y = 30.0f;
    m_pan_x = 0.0f;
    m_pan_y = 0.0f;
    Refresh();
}

References m_pan_x, m_pan_y, m_rot_x, m_rot_y, and m_zoom.

Referenced by handle_reset_overlay_mouse().

Here is the caller graph for this function:

set_computing_overlay()

void Slic3r::GUI::TexturePreviewCanvas::set_computing_overlay

(

bool

show

)

{
    Refresh();
}

set_face_colors()

void Slic3r::GUI::TexturePreviewCanvas::set_face_colors

(

const std::vector< std::array< std::size_t, 3 > > &

face_colors

)

{
    convert_face_colors(face_colors, m_face_colors_rgb);
    Refresh();
}

References Slic3r::GUI::convert_face_colors(), and m_face_colors_rgb.

Here is the call graph for this function:

set_filament_color_map()

void Slic3r::GUI::TexturePreviewCanvas::set_filament_color_map

(

const std::map< std::array< std::size_t, 3 >, std::array< float, 3 > > &

color_map

)

{
    m_color_map = color_map;
    m_filament_colors_rgb.resize(m_face_colors_rgb.size());
    for (size_t i = 0; i < m_face_colors_rgb.size(); ++i) {
        std::array<std::size_t, 3> key = {
            (std::size_t)(m_face_colors_rgb[i][0] * 255.f + 0.5f),
            (std::size_t)(m_face_colors_rgb[i][1] * 255.f + 0.5f),
            (std::size_t)(m_face_colors_rgb[i][2] * 255.f + 0.5f)
        };
        auto it = color_map.find(key);
        if (it != color_map.end())
            m_filament_colors_rgb[i] = it->second;
        else
            m_filament_colors_rgb[i] = m_face_colors_rgb[i];
    }
    Refresh();
}

References m_color_map, m_face_colors_rgb, and m_filament_colors_rgb.

set_mesh_data()

void Slic3r::GUI::TexturePreviewCanvas::set_mesh_data	(	const std::vector< std::array< float, 3 > > &	vertices,
		const std::vector< std::array< int, 3 > > &	indices )

{
    m_vertices = vertices;
    m_indices  = indices;
    update_bounding_box();
    compute_smooth_normals();
    Refresh();
}

References compute_smooth_normals(), m_indices, m_vertices, and update_bounding_box().

Here is the call graph for this function:

set_original_face_colors()

void Slic3r::GUI::TexturePreviewCanvas::set_original_face_colors

(

const std::vector< std::array< std::size_t, 3 > > &

face_colors

)

{
    convert_face_colors(face_colors, m_original_face_colors_rgb);
    Refresh();
}

References Slic3r::GUI::convert_face_colors(), and m_original_face_colors_rgb.

Here is the call graph for this function:

set_painted_mesh_data()

void Slic3r::GUI::TexturePreviewCanvas::set_painted_mesh_data	(	const std::vector< std::array< float, 3 > > &	vertices,
		const std::vector< std::array< int, 3 > > &	indices )

{
    m_painted_vertices = vertices;
    m_painted_indices  = indices;
    Refresh();
}

References m_painted_indices, and m_painted_vertices.

set_render_mode()

void Slic3r::GUI::TexturePreviewCanvas::set_render_mode

(

RenderMode

mode

)

{
    if (m_mode != mode) {
        m_mode = mode;
        Refresh();
    }
}

References m_mode.

set_texture_data()

void Slic3r::GUI::TexturePreviewCanvas::set_texture_data	(	const std::vector< std::array< float, 2 > > &	uvs,
		const unsigned char *	tex_data,
		int	tex_w,
		int	tex_h,
		int	tex_channels )

{
    m_uvs = uvs;
    m_tex_w = tex_w;
    m_tex_h = tex_h;
    m_tex_channels = tex_channels;
    m_tex_dirty = true;
 
    size_t sz = (size_t)tex_w * tex_h * tex_channels;
    m_tex_data.assign(tex_data, tex_data + sz);
    Refresh();
}

References m_tex_channels, m_tex_data, m_tex_dirty, m_tex_h, m_tex_w, and m_uvs.

set_texture_render_data()

void Slic3r::GUI::TexturePreviewCanvas::set_texture_render_data	(	const std::vector< std::vector< unsigned char > > &	tex_pixels_rgb,
		const std::vector< int > &	tex_widths,
		const std::vector< int > &	tex_heights,
		const std::vector< std::array< std::array< float, 2 >, 3 > > &	face_uvs,
		const std::vector< int > &	face_tex_ids )

{
    m_tex_pixels_rgb = tex_pixels_rgb;
    m_tex_widths     = tex_widths;
    m_tex_heights    = tex_heights;
    m_face_uvs       = face_uvs;
    m_face_tex_ids   = face_tex_ids;
    m_multi_tex_dirty = true;
    Refresh();
}

References m_face_tex_ids, m_face_uvs, m_multi_tex_dirty, m_tex_heights, m_tex_pixels_rgb, and m_tex_widths.

update_bounding_box()

void Slic3r::GUI::TexturePreviewCanvas::update_bounding_box ( )

private

{
    if (m_vertices.empty()) return;
    std::array<float, 3> mn = m_vertices[0], mx = m_vertices[0];
    for (const auto& v : m_vertices) {
        for (int i = 0; i < 3; ++i) {
            mn[i] = std::min(mn[i], v[i]);
            mx[i] = std::max(mx[i], v[i]);
        }
    }
    m_center = { (mn[0]+mx[0])/2, (mn[1]+mx[1])/2, (mn[2]+mx[2])/2 };
    float dx = mx[0]-mn[0], dy = mx[1]-mn[1], dz = mx[2]-mn[2];
    m_radius = std::sqrt(dx*dx + dy*dy + dz*dz) / 2.0f;
    if (m_radius < 1e-6f) m_radius = 1.0f;
}

References m_center, m_radius, and m_vertices.

Referenced by set_mesh_data().

Here is the caller graph for this function:

upload_reset_icon_texture()

unsigned int Slic3r::GUI::TexturePreviewCanvas::upload_reset_icon_texture ( const std::string & icon_name )

private

{
    wxBitmap bmp = create_scaled_bitmap(icon_name, this, 40);
    if (!bmp.IsOk())
        return 0;
 
    wxImage image = bmp.ConvertToImage();
    if (!image.IsOk())
        return 0;
 
    const int w = image.GetWidth();
    const int h = image.GetHeight();
    const unsigned char* rgb = image.GetData();
    const unsigned char* alpha = image.HasAlpha() ? image.GetAlpha() : nullptr;
    if (!rgb || w <= 0 || h <= 0)
        return 0;
 
    std::vector<unsigned char> rgba((size_t)w * h * 4);
    for (int i = 0; i < w * h; ++i) {
        rgba[(size_t)i * 4 + 0] = rgb[i * 3 + 0];
        rgba[(size_t)i * 4 + 1] = rgb[i * 3 + 1];
        rgba[(size_t)i * 4 + 2] = rgb[i * 3 + 2];
        rgba[(size_t)i * 4 + 3] = alpha ? alpha[i] : 255;
    }
 
    GLuint tex_id = 0;
    glGenTextures(1, &tex_id);
    glBindTexture(GL_TEXTURE_2D, tex_id);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgba.data());
    glBindTexture(GL_TEXTURE_2D, 0);
    return tex_id;
}

References create_scaled_bitmap(), GL_CLAMP_TO_EDGE, GL_LINEAR, GL_RGBA, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_UNPACK_ALIGNMENT, GL_UNSIGNED_BYTE, glBindTexture, glGenTextures, glPixelStorei, glTexImage2D, and glTexParameteri.

Referenced by upload_reset_icon_textures().

Here is the call graph for this function:

Here is the caller graph for this function:

upload_reset_icon_textures()

void Slic3r::GUI::TexturePreviewCanvas::upload_reset_icon_textures ( )

private

{
    if (m_reset_icon_tex && m_reset_icon_hover_tex && m_reset_icon_dark_tex && m_reset_icon_dark_hover_tex)
        return;
 
    if (!m_reset_icon_tex)
        m_reset_icon_tex = upload_reset_icon_texture("canvas_zoom");
    if (!m_reset_icon_hover_tex)
        m_reset_icon_hover_tex = upload_reset_icon_texture("canvas_zoom_hover");
    if (!m_reset_icon_dark_tex)
        m_reset_icon_dark_tex = upload_reset_icon_texture("canvas_zoom_dark");
    if (!m_reset_icon_dark_hover_tex)
        m_reset_icon_dark_hover_tex = upload_reset_icon_texture("canvas_zoom_dark_hover");
}

References m_reset_icon_dark_hover_tex, m_reset_icon_dark_tex, m_reset_icon_hover_tex, m_reset_icon_tex, and upload_reset_icon_texture().

Referenced by render_reset_overlay().

Here is the call graph for this function:

Here is the caller graph for this function:

upload_textures()

void Slic3r::GUI::TexturePreviewCanvas::upload_textures ( )

private

{
    if (!m_multi_tex_dirty) return;
    m_multi_tex_dirty = false;
 
    for (unsigned int id : m_gl_tex_ids)
        if (id) glDeleteTextures(1, &id);
    m_gl_tex_ids.clear();
 
    m_gl_tex_ids.resize(m_tex_pixels_rgb.size(), 0);
    for (size_t i = 0; i < m_tex_pixels_rgb.size(); ++i) {
        if (m_tex_pixels_rgb[i].empty() || m_tex_widths[i] <= 0 || m_tex_heights[i] <= 0)
            continue;
        GLuint tex_id = 0;
        glGenTextures(1, &tex_id);
        glBindTexture(GL_TEXTURE_2D, tex_id);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_tex_widths[i], m_tex_heights[i],
                     0, GL_RGB, GL_UNSIGNED_BYTE, m_tex_pixels_rgb[i].data());
        m_gl_tex_ids[i] = tex_id;
    }
    glBindTexture(GL_TEXTURE_2D, 0);
}

References Slic3r::empty(), GL_LINEAR, GL_REPEAT, GL_RGB, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_UNSIGNED_BYTE, glBindTexture, glDeleteTextures, glGenTextures, glTexImage2D, glTexParameteri, m_gl_tex_ids, m_multi_tex_dirty, m_tex_heights, m_tex_pixels_rgb, and m_tex_widths.

Referenced by render_textured_original().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_center

std::array<float, 3> Slic3r::GUI::TexturePreviewCanvas::m_center = {0, 0, 0}

private

{0, 0, 0};

Referenced by render(), and update_bounding_box().

m_color_map

std::map<std::array<std::size_t, 3>, std::array<float, 3> > Slic3r::GUI::TexturePreviewCanvas::m_color_map

private

Referenced by set_filament_color_map().

m_context

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

private

Referenced by TexturePreviewCanvas(), ~TexturePreviewCanvas(), and on_paint().

m_drag_mode

DragMode Slic3r::GUI::TexturePreviewCanvas::m_drag_mode = DragMode::None

private

Referenced by TexturePreviewCanvas(), handle_reset_overlay_mouse(), and on_mouse().

m_face_colors_rgb

std::vector<std::array<float, 3> > Slic3r::GUI::TexturePreviewCanvas::m_face_colors_rgb

private

Referenced by render_mesh(), set_face_colors(), and set_filament_color_map().

m_face_tex_ids

std::vector<int> Slic3r::GUI::TexturePreviewCanvas::m_face_tex_ids

private

Referenced by render_textured_original(), and set_texture_render_data().

m_face_uvs

std::vector<std::array<std::array<float,2>, 3> > Slic3r::GUI::TexturePreviewCanvas::m_face_uvs

private

Referenced by render_mesh(), render_textured_original(), and set_texture_render_data().

m_filament_colors_rgb

std::vector<std::array<float, 3> > Slic3r::GUI::TexturePreviewCanvas::m_filament_colors_rgb

private

Referenced by render_mesh(), and set_filament_color_map().

m_gl_initialized

bool Slic3r::GUI::TexturePreviewCanvas::m_gl_initialized = false

private

Referenced by ensure_gl_ready().

m_gl_tex_ids

std::vector<unsigned int> Slic3r::GUI::TexturePreviewCanvas::m_gl_tex_ids

private

Referenced by ~TexturePreviewCanvas(), render_textured_original(), and upload_textures().

m_indices

std::vector<std::array<int, 3> > Slic3r::GUI::TexturePreviewCanvas::m_indices

private

Referenced by compute_smooth_normals(), render_mesh(), render_textured_original(), and set_mesh_data().

m_last_mouse_pos

wxPoint Slic3r::GUI::TexturePreviewCanvas::m_last_mouse_pos

private

Referenced by on_mouse().

m_mode

RenderMode Slic3r::GUI::TexturePreviewCanvas::m_mode = RenderMode::Original

private

Referenced by get_render_mode(), render_mesh(), and set_render_mode().

m_multi_tex_dirty

bool Slic3r::GUI::TexturePreviewCanvas::m_multi_tex_dirty = false

private

Referenced by set_texture_render_data(), and upload_textures().

m_original_face_colors_rgb

std::vector<std::array<float, 3> > Slic3r::GUI::TexturePreviewCanvas::m_original_face_colors_rgb

private

Referenced by render_mesh(), render_textured_original(), and set_original_face_colors().

m_painted_indices

std::vector<std::array<int, 3> > Slic3r::GUI::TexturePreviewCanvas::m_painted_indices

private

Referenced by render_mesh(), and set_painted_mesh_data().

m_painted_vertices

std::vector<std::array<float, 3> > Slic3r::GUI::TexturePreviewCanvas::m_painted_vertices

private

Referenced by render_mesh(), and set_painted_mesh_data().

m_pan_x

float Slic3r::GUI::TexturePreviewCanvas::m_pan_x = 0.0f

private

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

m_pan_y

float Slic3r::GUI::TexturePreviewCanvas::m_pan_y = 0.0f

private

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

m_radius

float Slic3r::GUI::TexturePreviewCanvas::m_radius = 1.0f

private

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

m_reset_icon_dark_hover_tex

unsigned int Slic3r::GUI::TexturePreviewCanvas::m_reset_icon_dark_hover_tex = 0

private

Referenced by ~TexturePreviewCanvas(), render_reset_overlay(), and upload_reset_icon_textures().

m_reset_icon_dark_tex

unsigned int Slic3r::GUI::TexturePreviewCanvas::m_reset_icon_dark_tex = 0

private

Referenced by ~TexturePreviewCanvas(), render_reset_overlay(), and upload_reset_icon_textures().

m_reset_icon_hover_tex

unsigned int Slic3r::GUI::TexturePreviewCanvas::m_reset_icon_hover_tex = 0

private

Referenced by ~TexturePreviewCanvas(), render_reset_overlay(), and upload_reset_icon_textures().

m_reset_icon_tex

unsigned int Slic3r::GUI::TexturePreviewCanvas::m_reset_icon_tex = 0

private

Referenced by ~TexturePreviewCanvas(), render_reset_overlay(), and upload_reset_icon_textures().

m_reset_overlay_hovered

bool Slic3r::GUI::TexturePreviewCanvas::m_reset_overlay_hovered = false

private

Referenced by handle_reset_overlay_mouse(), and render_reset_overlay().

m_reset_overlay_pressed

bool Slic3r::GUI::TexturePreviewCanvas::m_reset_overlay_pressed = false

private

Referenced by TexturePreviewCanvas(), and handle_reset_overlay_mouse().

m_rot_x

float Slic3r::GUI::TexturePreviewCanvas::m_rot_x = -30.0f

private

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

m_rot_y

float Slic3r::GUI::TexturePreviewCanvas::m_rot_y = 30.0f

private

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

m_tex_channels

int Slic3r::GUI::TexturePreviewCanvas::m_tex_channels = 3

private

Referenced by set_texture_data().

m_tex_data

std::vector<unsigned char> Slic3r::GUI::TexturePreviewCanvas::m_tex_data

private

Referenced by set_texture_data().

m_tex_dirty

bool Slic3r::GUI::TexturePreviewCanvas::m_tex_dirty = false

private

Referenced by set_texture_data().

m_tex_h

int Slic3r::GUI::TexturePreviewCanvas::m_tex_h = 0

private

Referenced by set_texture_data().

m_tex_heights

std::vector<int> Slic3r::GUI::TexturePreviewCanvas::m_tex_heights

private

Referenced by set_texture_render_data(), and upload_textures().

m_tex_id

unsigned int Slic3r::GUI::TexturePreviewCanvas::m_tex_id = 0

private

Referenced by ~TexturePreviewCanvas().

m_tex_pixels_rgb

std::vector<std::vector<unsigned char> > Slic3r::GUI::TexturePreviewCanvas::m_tex_pixels_rgb

private

Referenced by set_texture_render_data(), and upload_textures().

m_tex_w

int Slic3r::GUI::TexturePreviewCanvas::m_tex_w = 0

private

Referenced by set_texture_data().

m_tex_widths

std::vector<int> Slic3r::GUI::TexturePreviewCanvas::m_tex_widths

private

Referenced by set_texture_render_data(), and upload_textures().

m_uvs

std::vector<std::array<float, 2> > Slic3r::GUI::TexturePreviewCanvas::m_uvs

private

Referenced by set_texture_data().

m_vertex_normals

std::vector<std::array<float, 3> > Slic3r::GUI::TexturePreviewCanvas::m_vertex_normals

private

Referenced by compute_smooth_normals(), render_mesh(), and render_textured_original().

m_vertices

std::vector<std::array<float, 3> > Slic3r::GUI::TexturePreviewCanvas::m_vertices

private

Referenced by compute_smooth_normals(), render_mesh(), render_textured_original(), set_mesh_data(), and update_bounding_box().

m_zoom

float Slic3r::GUI::TexturePreviewCanvas::m_zoom = 1.0f

private

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

---

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

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