Slic3r::GUI::GLTexture Class Reference

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

Collaboration diagram for Slic3r::GUI::GLTexture:

Classes
class	Compressor
struct	UV
struct	Quad_UVs

Public Types
enum	ECompressionType : unsigned char { None , SingleThreaded , MultiThreaded }

Public Member Functions
	GLTexture ()
virtual	~GLTexture ()
bool	load_from_file (const std::string &filename, bool use_mipmaps, ECompressionType compression_type, bool apply_anisotropy)
bool	load_from_svg_file (const std::string &filename, bool use_mipmaps, bool compress, bool apply_anisotropy, unsigned int max_size_px)
bool	load_from_raw_data (std::vector< unsigned char > data, unsigned int w, unsigned int h, bool apply_anisotropy=false, bool use_mipmaps=true)
bool	load_from_svg_files_as_sprites_array (const std::vector< std::string > &filenames, const std::vector< std::pair< int, bool > > &states, unsigned int sprite_size_px, bool compress)
void	reset ()
bool	generate_texture_from_text (const std::string &text_str, wxFont &font, int &ww, int &hh, int &hl, wxColor background= *wxBLACK, wxColor foreground= *wxWHITE)
bool	generate_from_text (const std::string &text_str, wxFont &font, wxColor background= *wxBLACK, wxColor foreground= *wxWHITE)
bool	generate_from_text_string (const std::string &text_str, wxFont &font, wxColor background= *wxBLACK, wxColor foreground= *wxWHITE)
unsigned int	get_id () const
int	get_original_width () const
int	get_width () const
int	get_height () const
const std::string &	get_source () const
bool	unsent_compressed_data_available () const
void	send_compressed_data_to_gpu ()
bool	all_compressed_data_sent_to_gpu () const

Static Public Member Functions
static void	render_texture (unsigned int tex_id, float left, float right, float bottom, float top)
static void	render_sub_texture (unsigned int tex_id, float left, float right, float bottom, float top, const Quad_UVs &uvs)
static void	copy_from_framebuffer (unsigned int &tex_id, std::array< unsigned int, 2 > &tex_size, unsigned int width, unsigned int height, int filter)

Public Attributes
int	m_original_width
int	m_original_height

Static Public Attributes
static Quad_UVs	FullTextureUVs = { { 0.0f, 1.0f }, { 1.0f, 1.0f }, { 1.0f, 0.0f }, { 0.0f, 0.0f } }

Protected Attributes
unsigned int	m_id { 0 }
int	m_width { 0 }
int	m_height { 0 }
std::string	m_source
Compressor	m_compressor

Private Member Functions
bool	load_from_png (const std::string &filename, bool use_mipmaps, ECompressionType compression_type, bool apply_anisotropy)
bool	load_from_svg (const std::string &filename, bool use_mipmaps, bool compress, bool apply_anisotropy, unsigned int max_size_px)

Friends
class	Compressor

Detailed Description

---

Class Documentation

Slic3r::GUI::GLTexture::UV

struct Slic3r::GUI::GLTexture::UV

Class Members
float	u { 0.0f }
float	v { 0.0f }

Slic3r::GUI::GLTexture::Quad_UVs

struct Slic3r::GUI::GLTexture::Quad_UVs

Collaboration diagram for Slic3r::GUI::GLTexture::Quad_UVs:

Class Members
UV	left_bottom
UV	left_top
UV	right_bottom
UV	right_top

Member Enumeration Documentation

ECompressionType

enum Slic3r::GUI::GLTexture::ECompressionType : unsigned char

Enumerator
None
SingleThreaded
MultiThreaded

        {
            None,
            SingleThreaded,
            MultiThreaded
        };

Constructor & Destructor Documentation

GLTexture()

Slic3r::GUI::GLTexture::GLTexture

(

)

    : m_compressor(*this)
{
}

References m_compressor.

Referenced by Slic3r::GUI::GLTexture::Compressor::Compressor().

Here is the caller graph for this function:

~GLTexture()

Slic3r::GUI::GLTexture::~GLTexture ( )

virtual

{
    reset();
}

References reset().

Here is the call graph for this function:

Member Function Documentation

all_compressed_data_sent_to_gpu()

bool Slic3r::GUI::GLTexture::all_compressed_data_sent_to_gpu ( ) const

inline

{ return m_compressor.all_compressed_data_sent_to_gpu(); }

References m_compressor.

copy_from_framebuffer()

void Slic3r::GUI::GLTexture::copy_from_framebuffer ( unsigned int & tex_id, std::array< unsigned int, 2 > & tex_size, unsigned int width, unsigned int height, int filter )

static

{
    if (tex_id == 0) {
        glsafe(::glGenTextures(1, &tex_id));
        glsafe(::glBindTexture(GL_TEXTURE_2D, tex_id));
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter));
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter));
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
    }
    else
        glsafe(::glBindTexture(GL_TEXTURE_2D, tex_id));
 
    if (tex_size[0] != width || tex_size[1] != height) {
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr));
        tex_size = { width, height };
    }
 
    // Copying from the default framebuffer resolves its multisampling.
    glsafe(::glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, width, height));
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
}

References GL_CLAMP_TO_EDGE, GL_RGBA, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_UNSIGNED_BYTE, glBindTexture, glCopyTexSubImage2D, glGenTextures, glsafe, glTexImage2D, and glTexParameteri.

Referenced by Slic3r::GUI::GLCanvas3D::_render_fxaa_pass(), and Slic3r::GUI::SceneCache::capture().

Here is the caller graph for this function:

generate_from_text()

bool Slic3r::GUI::GLTexture::generate_from_text	(	const std::string &	text_str,
		wxFont &	font,
		wxColor	background = *wxBLACK,
		wxColor	foreground = *wxWHITE )

{
    if (text_str.empty())
    {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":no text string, should not happen\n";
        return false;
    }
 
    wxString msg = from_u8(text_str);
    wxMemoryDC memDC;
 
    memDC.SetFont(font);
 
    // calculates texture size
    wxCoord w, h;
    memDC.GetMultiLineTextExtent(msg, &w, &h);
 
    m_original_width = (int)w;
    m_original_height = (int)h;
    m_width = (int)next_highest_power_of_2((uint32_t)w);
    m_height = (int)next_highest_power_of_2((uint32_t)h);
 
    // generates bitmap
    wxBitmap bitmap(m_width, m_height);
 
    memDC.SelectObject(bitmap);
    memDC.SetBackground(wxBrush(background));
    memDC.Clear();
 
    // draw message
    memDC.SetTextForeground(*wxWHITE);
    memDC.DrawLabel(msg, wxRect(0, 0, m_original_width, m_original_height), wxALIGN_CENTER);
 
    memDC.SelectObject(wxNullBitmap);
 
    // Convert the bitmap into a linear data ready to be loaded into the GPU.
    wxImage image = bitmap.ConvertToImage();
 
    // prepare buffer
    std::vector<unsigned char> data(4 * m_width * m_height, 0);
    const unsigned char* src = image.GetData();
    /* for debug use
    std::ofstream fout;
    fout.open(text_str+std::to_string(m_width)+"_"+std::to_string(m_height)+".rgb", std::ios::out);
    fout.write((const char*)src, 3 * m_width * m_height);
    fout.close();*/
    for (int h = 0; h < m_height; ++h) {
        unsigned char* dst = data.data() + 4 * h * m_width;
        for (int w = 0; w < m_width; ++w) {
            *dst++ = foreground.Red();
            *dst++ = foreground.Green();
            *dst++ = foreground.Blue();
            *dst++ = (unsigned char)std::min<int>(255, *src);
            src += 3;
        }
    }
 
    // sends buffer to gpu
    glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
    glsafe(::glGenTextures(1, &m_id));
    glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)m_id));
    if (OpenGLManager::are_compressed_textures_supported())
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
    else
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
 
    return true;
}

References Slic3r::GUI::OpenGLManager::are_compressed_textures_supported(), Slic3r::GUI::from_u8(), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_LINEAR, GL_RGBA, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_MIN_FILTER, GL_UNPACK_ALIGNMENT, GL_UNSIGNED_BYTE, glBindTexture, glGenTextures, glPixelStorei, glsafe, glTexImage2D, glTexParameteri, m_height, m_id, m_original_height, m_original_width, m_width, and Slic3r::next_highest_power_of_2().

Referenced by generate_from_text_string().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_from_text_string()

bool Slic3r::GUI::GLTexture::generate_from_text_string	(	const std::string &	text_str,
		wxFont &	font,
		wxColor	background = *wxBLACK,
		wxColor	foreground = *wxWHITE )

{
    return generate_from_text(text_str, font, background, foreground);
}

References generate_from_text().

Here is the call graph for this function:

generate_texture_from_text()

bool Slic3r::GUI::GLTexture::generate_texture_from_text	(	const std::string &	text_str,
		wxFont &	font,
		int &	ww,
		int &	hh,
		int &	hl,
		wxColor	background = *wxBLACK,
		wxColor	foreground = *wxWHITE )

{
    if (text_str.empty())
    {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":no text string, should not happen\n";
        return false;
    }
 
    wxString msg = _(text_str);
    wxMemoryDC memDC;
 
    memDC.SetFont(font);
 
    // calculates texture size
    wxCoord w, h, ll;
    wxClientDC dc(wxGetApp().GetTopWindow());
    dc.SetFont(font);
    dc.GetMultiLineTextExtent(msg, &w, &h, &ll, &font);
 
 
    m_original_width = (int)w;
    m_original_height = (int)h;
    m_width = (int)next_highest_power_of_2((uint32_t)w);
    m_height = (int)next_highest_power_of_2((uint32_t)h);
    ww = m_width;
    hh = m_height;
    hl = ll;
    // generates bitmap
    wxBitmap bitmap(m_width, m_height);
 
    memDC.SelectObject(bitmap);
    memDC.SetBackground(wxBrush(background));
    memDC.Clear();
 
    // draw message
    memDC.SetTextForeground(*wxWHITE);
    memDC.DrawLabel(msg, wxRect(0, 0, m_width, m_height), wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
 
    memDC.SelectObject(wxNullBitmap);
 
    // Convert the bitmap into a linear data ready to be loaded into the GPU.
    wxImage image = bitmap.ConvertToImage();
 
    // prepare buffer
    std::vector<unsigned char> data(4 * m_width * m_height, 0);
    const unsigned char* src = image.GetData();
    /* for debug use
    std::ofstream fout;
    fout.open(text_str+std::to_string(m_width)+"_"+std::to_string(m_height)+".rgb", std::ios::out);
    fout.write((const char*)src, 3 * m_width * m_height);
    fout.close();*/
    bool found = false;
    for (int h = 0; h < m_height; ++h) {
        unsigned char* dst = data.data() + 4 * h * m_width;
        for (int w = 0; w < m_width; ++w) {
            *dst++ = foreground.Red();
            *dst++ = foreground.Green();
            *dst++ = foreground.Blue();
            *dst++ = (unsigned char)std::min<int>(255, *src);
            if ((*src) != background.Red() && !found) {
                found = true;
                if (m_height - h < font.GetPointSize())
                    return false;
            }
            src += 3;
        }
    }
    if (!found)
        return false;
 
    found = false;
    src -= 3;
    for (int h = m_height; h > 0; --h) {
        for (int w = m_width; w > 0; --w) {
            if ((*src) != background.Red() && !found) {
                found = true;
                if (h < font.GetPointSize())
                    return false;
            }
            src -= 3;
        }
    }
    if (!found)
        return false;
 
    // sends buffer to gpu
    glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
    glsafe(::glGenTextures(1, &m_id));
    glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)m_id));
    if (OpenGLManager::are_compressed_textures_supported())
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
    else
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
 
    return true;
}

References _, Slic3r::GUI::OpenGLManager::are_compressed_textures_supported(), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_LINEAR, GL_RGBA, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_MIN_FILTER, GL_UNPACK_ALIGNMENT, GL_UNSIGNED_BYTE, glBindTexture, glGenTextures, glPixelStorei, glsafe, glTexImage2D, glTexParameteri, m_height, m_id, m_original_height, m_original_width, m_width, and Slic3r::next_highest_power_of_2().

Here is the call graph for this function:

get_height()

int Slic3r::GUI::GLTexture::get_height ( ) const

inline

{ return m_height; }

References m_height.

Referenced by Slic3r::GUI::PartPlate::calc_vertex_for_plate_name_edit_icon(), Slic3r::GUI::GLGizmoTextureDisplacement::render_shaded_preview_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_texture_library_popup(), and Slic3r::GUI::GLGizmoTextureDisplacement::shaded_preview_ready().

Here is the caller graph for this function:

get_id()

unsigned int Slic3r::GUI::GLTexture::get_id ( ) const

inline

{ return m_id; }

References m_id.

Referenced by Slic3r::GUI::GLCanvas3D::_render_imgui_select_plate_toolbar(), Slic3r::GUI::PartPlate::render_icon_texture(), Slic3r::GUI::PartPlate::render_logo_texture(), Slic3r::GUI::GLGizmoTextureDisplacement::render_shaded_preview_mesh(), and Slic3r::GUI::GLGizmoTextureDisplacement::render_texture_library_popup().

Here is the caller graph for this function:

get_original_width()

int Slic3r::GUI::GLTexture::get_original_width ( ) const

inline

{ return m_original_width; }

References m_original_width.

get_source()

const std::string & Slic3r::GUI::GLTexture::get_source ( ) const

inline

{ return m_source; }

References m_source.

get_width()

int Slic3r::GUI::GLTexture::get_width ( ) const

inline

{ return m_width; }

References m_width.

Referenced by Slic3r::GUI::PartPlate::calc_vertex_for_plate_name_edit_icon(), Slic3r::GUI::GLGizmoTextureDisplacement::render_shaded_preview_mesh(), Slic3r::GUI::GLGizmoTextureDisplacement::render_texture_library_popup(), and Slic3r::GUI::GLGizmoTextureDisplacement::shaded_preview_ready().

Here is the caller graph for this function:

load_from_file()

bool Slic3r::GUI::GLTexture::load_from_file	(	const std::string &	filename,
		bool	use_mipmaps,
		ECompressionType	compression_type,
		bool	apply_anisotropy )

{
    reset();
 
    if (!boost::filesystem::exists(filename))
        return false;
 
    if (boost::algorithm::iends_with(filename, ".png"))
        return load_from_png(filename, use_mipmaps, compression_type, apply_anisotropy);
    else
        return false;
}

References load_from_png(), and reset().

Here is the call graph for this function:

load_from_png()

bool Slic3r::GUI::GLTexture::load_from_png ( const std::string & filename, bool use_mipmaps, ECompressionType compression_type, bool apply_anisotropy )

private

{
    const bool compression_enabled = (compression_type != None) && OpenGLManager::are_compressed_textures_supported();
 
    // Load a PNG with an alpha channel.
    wxImage image;
    if (!image.LoadFile(wxString::FromUTF8(filename.c_str()), wxBITMAP_TYPE_PNG)) {
        reset();
        return false;
    }
 
    m_width = image.GetWidth();
    m_height = image.GetHeight();
 
    bool requires_rescale = false;
 
    if (use_mipmaps && compression_enabled && OpenGLManager::force_power_of_two_textures()) {
        if (to_squared_power_of_two(boost::filesystem::path(filename).filename().string(), OpenGLManager::get_gl_info().get_max_tex_size(), m_width, m_height))
            requires_rescale = true;
    }
 
    if (compression_enabled && compression_type == MultiThreaded) {
        // the stb_dxt compression library seems to like only texture sizes which are a multiple of 4
        int width_rem = m_width % 4;
        int height_rem = m_height % 4;
 
        if (width_rem != 0) {
            m_width += (4 - width_rem);
            requires_rescale = true;
        }
 
        if (height_rem != 0) {
            m_height += (4 - height_rem);
            requires_rescale = true;
        }
    }
 
    if (requires_rescale)
        image = image.ResampleBicubic(m_width, m_height);
 
    int n_pixels = m_width * m_height;
    if (n_pixels <= 0) {
        reset();
        return false;
    }
 
    // Get RGB & alpha raw data from wxImage, pack them into an array.
    unsigned char* img_rgb = image.GetData();
    if (img_rgb == nullptr) {
        reset();
        return false;
    }
 
    unsigned char* img_alpha = image.GetAlpha();
 
    std::vector<unsigned char> data(n_pixels * 4, 0);
    for (int i = 0; i < n_pixels; ++i) {
        int data_id = i * 4;
        int img_id = i * 3;
        data[data_id + 0] = img_rgb[img_id + 0];
        data[data_id + 1] = img_rgb[img_id + 1];
        data[data_id + 2] = img_rgb[img_id + 2];
        data[data_id + 3] = (img_alpha != nullptr) ? img_alpha[i] : 255;
    }
 
    // sends data to gpu
    glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
    glsafe(::glGenTextures(1, &m_id));
    glsafe(::glBindTexture(GL_TEXTURE_2D, m_id));
 
    if (apply_anisotropy) {
        GLfloat max_anisotropy = OpenGLManager::get_gl_info().get_max_anisotropy();
        if (max_anisotropy > 1.0f)
            glsafe(::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropy));
    }
 
    if (compression_enabled) {
        if (compression_type == SingleThreaded)
            glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
        else {
            // initializes the texture on GPU
            glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0));
            // and send the uncompressed data to the compressor
            m_compressor.add_level((unsigned int)m_width, (unsigned int)m_height, data);
        }
    }
    else
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
 
    if (use_mipmaps) {
        // we manually generate mipmaps because glGenerateMipmap() function is not reliable on all graphics cards
        int lod_w = m_width;
        int lod_h = m_height;
        GLint level = 0;
        while (lod_w > 1 || lod_h > 1) {
            ++level;
 
            lod_w = std::max(lod_w / 2, 1);
            lod_h = std::max(lod_h / 2, 1);
            n_pixels = lod_w * lod_h;
 
            image = image.ResampleBicubic(lod_w, lod_h);
 
            data.resize(n_pixels * 4);
 
            img_rgb = image.GetData();
            img_alpha = image.GetAlpha();
 
            for (int i = 0; i < n_pixels; ++i) {
                int data_id = i * 4;
                int img_id = i * 3;
                data[data_id + 0] = img_rgb[img_id + 0];
                data[data_id + 1] = img_rgb[img_id + 1];
                data[data_id + 2] = img_rgb[img_id + 2];
                data[data_id + 3] = (img_alpha != nullptr) ? img_alpha[i] : 255;
            }
 
            if (compression_enabled) {
                if (compression_type == SingleThreaded)
                    glsafe(::glTexImage2D(GL_TEXTURE_2D, level, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
                else {
                    // initializes the texture on GPU
                    glsafe(::glTexImage2D(GL_TEXTURE_2D, level, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)lod_w, (GLsizei)lod_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0));
                    // and send the uncompressed data to the compressor
                    m_compressor.add_level((unsigned int)lod_w, (unsigned int)lod_h, data);
                }
            }
            else
                glsafe(::glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, (GLsizei)lod_w, (GLsizei)lod_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
        }
 
        if (!compression_enabled) {
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, level));
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR));
        }
    }
    else {
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
    }
 
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
 
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
 
    m_source = filename;
 
    if (compression_type == MultiThreaded)
        // start asynchronous compression
        m_compressor.start_compressing();
 
    return true;
}

References Slic3r::GUI::OpenGLManager::are_compressed_textures_supported(), Slic3r::GUI::OpenGLManager::force_power_of_two_textures(), Slic3r::GUI::OpenGLManager::get_gl_info(), Slic3r::GUI::OpenGLManager::GLInfo::get_max_anisotropy(), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, GL_RGBA, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MAX_ANISOTROPY_EXT, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_MIN_FILTER, GL_UNPACK_ALIGNMENT, GL_UNSIGNED_BYTE, glBindTexture, glGenTextures, glPixelStorei, glsafe, glTexImage2D, glTexParameterf, glTexParameteri, m_compressor, m_height, m_id, m_source, m_width, MultiThreaded, None, reset(), SingleThreaded, and Slic3r::GUI::to_squared_power_of_two().

Referenced by load_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

load_from_raw_data()

bool Slic3r::GUI::GLTexture::load_from_raw_data	(	std::vector< unsigned char >	data,
		unsigned int	w,
		unsigned int	h,
		bool	apply_anisotropy = false,
		bool	use_mipmaps = true )

{
    m_width = w;
    m_height = h;
    int n_pixels = m_width * m_height;
    if (n_pixels <= 0) {
        reset();
        return false;
    }
 
    // sends data to gpu
    glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
    glsafe(::glGenTextures(1, &m_id));
    glsafe(::glBindTexture(GL_TEXTURE_2D, m_id));
 
    if (apply_anisotropy) {
        GLfloat max_anisotropy = OpenGLManager::get_gl_info().get_max_anisotropy();
        if (max_anisotropy > 1.0f)
            glsafe(::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropy));
    }
 
 
    glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
 
    if (use_mipmaps) {
        // We generate the mipmap chain ourselves rather than calling glGenerateMipmap(), which this
        // codebase has historically considered unreliable on some graphics cards.
        //
        // Each level is a 2x2 box filter of the level above it. Note this used to re-upload the
        // *level-0* buffer at every level instead, which does not downscale anything - it just
        // reinterprets the image's first lod_w * lod_h texels as the whole smaller level, i.e. every
        // level below 0 held a crop of the top-left corner. It went unnoticed for as long as every
        // caller drew these textures at roughly their native size (where only level 0 is ever
        // sampled); it shows up the moment one is drawn small enough to select a lower level, as a
        // texture that visibly turns into something else as it shrinks.
        std::vector<unsigned char> scratch;
        const std::vector<unsigned char> *src = &data;
        int src_w = m_width;
        int src_h = m_height;
        GLint level = 0;
        while (src_w > 1 || src_h > 1) {
            ++level;
            const int lod_w = std::max(src_w / 2, 1);
            const int lod_h = std::max(src_h / 2, 1);
 
            std::vector<unsigned char> lod(size_t(lod_w) * size_t(lod_h) * 4);
            for (int y = 0; y < lod_h; ++y) {
                // min() rather than a plain 2*y+1: an odd source extent leaves the last output texel
                // with only one source row/column to average, not two.
                const int y0 = std::min(2 * y, src_h - 1);
                const int y1 = std::min(2 * y + 1, src_h - 1);
                for (int x = 0; x < lod_w; ++x) {
                    const int x0 = std::min(2 * x, src_w - 1);
                    const int x1 = std::min(2 * x + 1, src_w - 1);
                    for (int c = 0; c < 4; ++c) {
                        const unsigned int sum = (*src)[(size_t(y0) * size_t(src_w) + size_t(x0)) * 4 + size_t(c)] +
                                                 (*src)[(size_t(y0) * size_t(src_w) + size_t(x1)) * 4 + size_t(c)] +
                                                 (*src)[(size_t(y1) * size_t(src_w) + size_t(x0)) * 4 + size_t(c)] +
                                                 (*src)[(size_t(y1) * size_t(src_w) + size_t(x1)) * 4 + size_t(c)];
                        lod[(size_t(y) * size_t(lod_w) + size_t(x)) * 4 + size_t(c)] = (unsigned char)(sum / 4);
                    }
                }
            }
            glsafe(::glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, (GLsizei)lod_w, (GLsizei)lod_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)lod.data()));
 
            scratch = std::move(lod);
            src     = &scratch;
            src_w   = lod_w;
            src_h   = lod_h;
        }
 
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, level));
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR));
    }
    else {
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
    }
 
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
 
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
 
#if 0
    // debug output
    static int pass = 0;
    ++pass;
 
    wxImage output(m_width, m_height);
    output.InitAlpha();
 
    for (int h = 0; h < m_height; ++h) {
        int px_h = h * m_width;
        for (int w = 0; w < m_width; ++w) {
            int offset = (px_h + w) * 4;
            output.SetRGB(w, h, data.data()[offset + 0], data.data()[offset + 1], data.data()[offset + 2]);
            output.SetAlpha(w, h, data.data()[offset + 3]);
        }
    }
 
    std::string out_filename = resources_dir() + "/images/test_" + std::to_string(pass) + ".png";
    output.SaveFile(out_filename, wxBITMAP_TYPE_PNG);
#endif // 0
    return true;
}

References Slic3r::GUI::OpenGLManager::get_gl_info(), Slic3r::GUI::OpenGLManager::GLInfo::get_max_anisotropy(), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, GL_RGBA, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MAX_ANISOTROPY_EXT, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_MIN_FILTER, GL_UNPACK_ALIGNMENT, GL_UNSIGNED_BYTE, glBindTexture, glGenTextures, glPixelStorei, glsafe, glTexImage2D, glTexParameterf, glTexParameteri, m_height, m_id, m_width, Slic3r::offset(), reset(), and Slic3r::resources_dir().

Here is the call graph for this function:

load_from_svg()

bool Slic3r::GUI::GLTexture::load_from_svg ( const std::string & filename, bool use_mipmaps, bool compress, bool apply_anisotropy, unsigned int max_size_px )

private

{
    const bool compression_enabled = compress && OpenGLManager::are_compressed_textures_supported();
 
    NSVGimage* image = nsvgParseFromFile(filename.c_str(), "px", 96.0f);
    if (image == nullptr) {
        reset();
        return false;
    }
 
    const float scale = (float)max_size_px / std::max(image->width, image->height);
 
    m_width = (int)(scale * image->width);
    m_height = (int)(scale * image->height);
 
    if (use_mipmaps && compression_enabled && OpenGLManager::force_power_of_two_textures())
        to_squared_power_of_two(boost::filesystem::path(filename).filename().string(), max_size_px, m_width, m_height);
 
    float scale_w = (float)m_width / image->width;
    float scale_h = (float)m_height / image->height;
 
    if (compression_enabled) {
        // the stb_dxt compression library seems to like only texture sizes which are a multiple of 4
        int width_rem = m_width % 4;
        int height_rem = m_height % 4;
 
        if (width_rem != 0)
            m_width += (4 - width_rem);
 
        if (height_rem != 0)
            m_height += (4 - height_rem);
    }
 
    const int n_pixels = m_width * m_height;
 
    if (n_pixels <= 0) {
        reset();
        nsvgDelete(image);
        return false;
    }
 
    NSVGrasterizer* rast = nsvgCreateRasterizer();
    if (rast == nullptr) {
        nsvgDelete(image);
        reset();
        return false;
    }
 
    // creates the temporary buffer only once, with max size, and reuse it for all the levels, if generating mipmaps
    std::vector<unsigned char> data(n_pixels * 4, 0);
    nsvgRasterizeXY(rast, image, 0, 0, scale_w, scale_h, data.data(), m_width, m_height, m_width * 4);
 
    // sends data to gpu
    glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
    glsafe(::glGenTextures(1, &m_id));
    glsafe(::glBindTexture(GL_TEXTURE_2D, m_id));
 
    if (apply_anisotropy) {
        GLfloat max_anisotropy = OpenGLManager::get_gl_info().get_max_anisotropy();
        if (max_anisotropy > 1.0f)
            glsafe(::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropy));
    }
 
    if (compression_enabled) {
        // initializes the texture on GPU
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0));
        // and send the uncompressed data to the compressor
        m_compressor.add_level((unsigned int)m_width, (unsigned int)m_height, data);
    }
    else
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
 
    if (use_mipmaps) {
        // we manually generate mipmaps because glGenerateMipmap() function is not reliable on all graphics cards
        int lod_w = m_width;
        int lod_h = m_height;
        GLint level = 0;
        while (lod_w >= 4 && lod_h >= 4) {
            ++level;
 
            lod_w = std::max(lod_w / 2, 1);
            lod_h = std::max(lod_h / 2, 1);
            scale_w /= 2.0f;
            scale_h /= 2.0f;
 
            data.resize(lod_w * lod_h * 4);
 
            nsvgRasterizeXY(rast, image, 0, 0, scale_w, scale_h, data.data(), lod_w, lod_h, lod_w * 4);
            if (compression_enabled) {
                // initializes the texture on GPU
                glsafe(::glTexImage2D(GL_TEXTURE_2D, level, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)lod_w, (GLsizei)lod_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0));
                // and send the uncompressed data to the compressor
                m_compressor.add_level((unsigned int)lod_w, (unsigned int)lod_h, data);
            }
            else
                glsafe(::glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, (GLsizei)lod_w, (GLsizei)lod_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
        }
 
        if (!compression_enabled) {
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, level));
            glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR));
        }
    }
    else {
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
        glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
    }
 
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
 
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
 
    m_source = filename;
 
    if (compression_enabled)
        // start asynchronous compression
        m_compressor.start_compressing();
 
    nsvgDeleteRasterizer(rast);
    nsvgDelete(image);
 
    return true;
}

References Slic3r::GUI::OpenGLManager::are_compressed_textures_supported(), Slic3r::GUI::OpenGLManager::force_power_of_two_textures(), Slic3r::GUI::OpenGLManager::get_gl_info(), Slic3r::GUI::OpenGLManager::GLInfo::get_max_anisotropy(), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, GL_RGBA, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MAX_ANISOTROPY_EXT, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_MIN_FILTER, GL_UNPACK_ALIGNMENT, GL_UNSIGNED_BYTE, glBindTexture, glGenTextures, glPixelStorei, glsafe, glTexImage2D, glTexParameterf, glTexParameteri, m_compressor, m_height, m_id, m_source, m_width, Slic3r::nsvgParseFromFile(), reset(), scale(), and Slic3r::GUI::to_squared_power_of_two().

Referenced by load_from_svg_file().

Here is the call graph for this function:

Here is the caller graph for this function:

load_from_svg_file()

bool Slic3r::GUI::GLTexture::load_from_svg_file	(	const std::string &	filename,
		bool	use_mipmaps,
		bool	compress,
		bool	apply_anisotropy,
		unsigned int	max_size_px )

{
    reset();
    auto svg_file = filename;
    Utils::slash_to_back_slash(svg_file);
    if (!boost::filesystem::exists(svg_file))
        return false;
 
    if (boost::algorithm::iends_with(svg_file, ".svg"))
        return load_from_svg(svg_file, use_mipmaps, compress, apply_anisotropy, max_size_px);
    else
        return false;
}

References load_from_svg(), reset(), and Slic3r::Utils::slash_to_back_slash().

Referenced by Slic3r::GUI::GLCanvas3D::_init_select_plate_toolbar(), Slic3r::GUI::PartPlateList::generate_icon_textures(), and Slic3r::GUI::load_next_part_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

load_from_svg_files_as_sprites_array()

bool Slic3r::GUI::GLTexture::load_from_svg_files_as_sprites_array	(	const std::vector< std::string > &	filenames,
		const std::vector< std::pair< int, bool > > &	states,
		unsigned int	sprite_size_px,
		bool	compress )

{
    reset();
 
    if (filenames.empty() || states.empty() || sprite_size_px == 0)
        return false;
 
    bool dark_mode = wxGetApp().app_config->get("dark_color_mode") == "1";
 
    // every tile needs to have a 1px border around it to avoid artifacts when linear sampling on its edges
    unsigned int sprite_size_px_ex = sprite_size_px + 1;
 
    m_width = 1 + (int)(sprite_size_px_ex * states.size());
    m_height = 1 + (int)(sprite_size_px_ex * filenames.size());
 
    int n_pixels = m_width * m_height;
    int sprite_n_pixels = sprite_size_px_ex * sprite_size_px_ex;
    int sprite_stride = sprite_size_px_ex * 4;
    int sprite_bytes = sprite_n_pixels * 4;
 
    if (n_pixels <= 0) {
        reset();
        return false;
    }
 
    std::vector<unsigned char> data(n_pixels * 4, 0);
    std::vector<unsigned char> sprite_data(sprite_bytes, 0);
    std::vector<unsigned char> sprite_white_only_data(sprite_bytes, 0); // normal
    std::vector<unsigned char> sprite_gray_only_data(sprite_bytes, 0); // disable
    std::vector<unsigned char> output_data(sprite_bytes, 0);
 
    //BBS
    std::vector<unsigned char> pressed_data(sprite_bytes, 0); // (gizmo) pressed
    std::vector<unsigned char> disable_data(sprite_bytes, 0);
    std::vector<unsigned char> hover_data(sprite_bytes, 0); // hover
 
    const unsigned char pressed_color[3] = {255, 255, 255};
    const unsigned char hover_color[3] = {255, 255, 255};
    const unsigned char normal_color[3] = {43, 52, 54};
    const unsigned char disable_color[3] = {200, 200, 200};
    const unsigned char pressed_color_dark[3] = {60, 60, 65};
    const unsigned char hover_color_dark[3] = {60, 60, 65};
    const unsigned char normal_color_dark[3] = {182, 182, 182};
    const unsigned char disable_color_dark[3] = {76, 76, 85};
 
    NSVGrasterizer* rast = nsvgCreateRasterizer();
    if (rast == nullptr) {
        reset();
        return false;
    }
 
    int sprite_id = -1;
    for (const std::string& filename : filenames) {
        ++sprite_id;
 
        if (!boost::filesystem::exists(filename))
            continue;
 
        if (!boost::algorithm::iends_with(filename, ".svg"))
            continue;
 
        NSVGimage* image = nsvgParseFromFile(filename.c_str(), "px", 96.0f);
        if (image == nullptr)
            continue;
 
        float scale = (float)sprite_size_px / std::max(image->width, image->height);
 
        // offset by 1 to leave the first pixel empty (both in x and y)
        nsvgRasterize(rast, image, 1, 1, scale, sprite_data.data(), sprite_size_px, sprite_size_px, sprite_stride);
 
        ::memcpy((void*)pressed_data.data(), (const void*)sprite_data.data(), sprite_bytes);
        for (int i = 0; i < sprite_n_pixels; ++i) {
            int offset = i * 4;
            if (pressed_data.data()[offset + 0] == 0 &&
                pressed_data.data()[offset + 1] == 0 &&
                pressed_data.data()[offset + 2] == 0) {
                hover_data.data()[offset + 0] = dark_mode ? pressed_color_dark[0] : pressed_color[0];
                hover_data.data()[offset + 0] = dark_mode ? pressed_color_dark[1] : pressed_color[1];
                hover_data.data()[offset + 0] = dark_mode ? pressed_color_dark[2] : pressed_color[2];
            }
        }
 
        ::memcpy((void*)disable_data.data(), (const void*)sprite_data.data(), sprite_bytes);
        for (int i = 0; i < sprite_n_pixels; ++i) {
            int offset = i * 4;
            if (disable_data.data()[offset] != 0)
                ::memset((void*)&disable_data.data()[offset], 200, 3);
        }
 
        ::memcpy((void*)hover_data.data(), (const void*)sprite_data.data(), sprite_bytes);
        for (int i = 0; i < sprite_n_pixels; ++i) {
            int offset = i * 4;
            if (hover_data.data()[offset + 0] == 0 &&
                hover_data.data()[offset + 1] == 0 &&
                hover_data.data()[offset + 2] == 0)
            {
                hover_data.data()[offset + 0] = dark_mode ? hover_color_dark[0] : hover_color[0];
                hover_data.data()[offset + 1] = dark_mode ? hover_color_dark[1] : hover_color[1];
                hover_data.data()[offset + 2] = dark_mode ? hover_color_dark[2] : hover_color[2];
            }
        }
 
        ::memcpy((void*)sprite_white_only_data.data(), (const void*)sprite_data.data(), sprite_bytes);
        for (int i = 0; i < sprite_n_pixels; ++i) {
            int offset = i * 4;
            if (sprite_white_only_data.data()[offset + 0] != 0 ||
                sprite_white_only_data.data()[offset + 1] != 0 ||
                sprite_white_only_data.data()[offset + 2] != 0) {
                sprite_white_only_data.data()[offset + 0] = dark_mode ? normal_color_dark[0] : normal_color[0];
                sprite_white_only_data.data()[offset + 1] = dark_mode ? normal_color_dark[1] : normal_color[1];
                sprite_white_only_data.data()[offset + 2] = dark_mode ? normal_color_dark[2] : normal_color[2];
            }
        }
 
        ::memcpy((void*)sprite_gray_only_data.data(), (const void*)sprite_data.data(), sprite_bytes);
        for (int i = 0; i < sprite_n_pixels; ++i) {
            int offset = i * 4;
            if (sprite_gray_only_data.data()[offset + 0] != 0 ||
                sprite_gray_only_data.data()[offset + 1] != 0 ||
                sprite_gray_only_data.data()[offset + 2] != 0) {
                sprite_gray_only_data.data()[offset + 0] = dark_mode ? disable_color_dark[0] : disable_color[0];
                sprite_gray_only_data.data()[offset + 1] = dark_mode ? disable_color_dark[1] : disable_color[1];
                sprite_gray_only_data.data()[offset + 2] = dark_mode ? disable_color_dark[2] : disable_color[2];
            }
        }
 
 
        int sprite_offset_px = sprite_id * (int)sprite_size_px_ex * m_width;
        int state_id = -1;
        for (const std::pair<int, bool>& state : states) {
            ++state_id;
 
            // select the sprite variant
            std::vector<unsigned char>* src = nullptr;
            switch (state.first)
            {
            case 1: { src = &sprite_white_only_data; break; }
            case 2: { src = &sprite_gray_only_data; break; }
            default: { src = &hover_data; break; }
            }
 
            // applies background, if needed
            if (state.second) {
                src = &pressed_data;
            }
 
            ::memcpy((void*)output_data.data(), (const void*)src->data(), sprite_bytes);
 
            //BBS use BBS pressed style
            //if (state.second) {
            //    float inv_255 = 1.0f / 255.0f;
            //    // offset by 1 to leave the first pixel empty (both in x and y)
            //    for (unsigned int r = 1; r <= sprite_size_px; ++r) {
            //        unsigned int offset_r = r * sprite_size_px_ex;
            //        for (unsigned int c = 1; c <= sprite_size_px; ++c) {
            //            unsigned int offset = (offset_r + c) * 4;
            //            float alpha = (float)output_data.data()[offset + 3] * inv_255;
            //            output_data.data()[offset + 0] = (unsigned char)(output_data.data()[offset + 0] * alpha);
            //            output_data.data()[offset + 1] = (unsigned char)(output_data.data()[offset + 1] * alpha);
            //            output_data.data()[offset + 2] = (unsigned char)(output_data.data()[offset + 2] * alpha);
            //            output_data.data()[offset + 3] = (unsigned char)(128 * (1.0f - alpha) + output_data.data()[offset + 3] * alpha);
            //        }
            //    }
            //}
 
            int state_offset_px = sprite_offset_px + state_id * sprite_size_px_ex;
            for (int j = 0; j < (int)sprite_size_px_ex; ++j) {
                ::memcpy((void*)&data.data()[(state_offset_px + j * m_width) * 4], (const void*)&output_data.data()[j * sprite_stride], sprite_stride);
            }
        }
 
        nsvgDelete(image);
    }
 
    nsvgDeleteRasterizer(rast);
 
    // sends data to gpu
    glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
    glsafe(::glGenTextures(1, &m_id));
    glsafe(::glBindTexture(GL_TEXTURE_2D, m_id));
    if (compress && OpenGLManager::are_compressed_textures_supported())
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
    else
        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
 
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
 
    m_source = filenames.front();
 
#if 0
    // debug output
    static int pass = 0;
    ++pass;
 
    wxImage output(m_width, m_height);
    output.InitAlpha();
 
    for (int h = 0; h < m_height; ++h) {
        int px_h = h * m_width;
        for (int w = 0; w < m_width; ++w) {
            int offset = (px_h + w) * 4;
            output.SetRGB(w, h, data.data()[offset + 0], data.data()[offset + 1], data.data()[offset + 2]);
            output.SetAlpha(w, h, data.data()[offset + 3]);
        }
    }
 
    std::string out_filename = resources_dir() + "/images/test_" + std::to_string(pass) + ".png";
    output.SaveFile(out_filename, wxBITMAP_TYPE_PNG);
#endif // 0
 
    return true;
}

References Slic3r::GUI::OpenGLManager::are_compressed_textures_supported(), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_LINEAR, GL_RGBA, GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_MIN_FILTER, GL_UNPACK_ALIGNMENT, GL_UNSIGNED_BYTE, glBindTexture, glGenTextures, glPixelStorei, glsafe, glTexImage2D, glTexParameteri, m_height, m_id, m_source, m_width, Slic3r::nsvgParseFromFile(), Slic3r::offset(), reset(), Slic3r::resources_dir(), and scale().

Here is the call graph for this function:

render_sub_texture()

void Slic3r::GUI::GLTexture::render_sub_texture ( unsigned int tex_id, float left, float right, float bottom, float top, const Quad_UVs & uvs )

static

{
    glsafe(::glEnable(GL_BLEND));
    // Orca: fix washed-out toolbar icons on Wayland: keep destination alpha at 1.0 so the compositor
    // does not treat anti-aliased icon edges as window transparency.
    glsafe(::glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
 
    glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)tex_id));
 
    GLModel::Geometry init_data;
    init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P2T2 };
    init_data.reserve_vertices(4);
    init_data.reserve_indices(6);
 
    // vertices
    init_data.add_vertex(Vec2f(left, bottom),  Vec2f(uvs.left_bottom.u, uvs.left_bottom.v));
    init_data.add_vertex(Vec2f(right, bottom), Vec2f(uvs.right_bottom.u, uvs.right_bottom.v));
    init_data.add_vertex(Vec2f(right, top),    Vec2f(uvs.right_top.u, uvs.right_top.v));
    init_data.add_vertex(Vec2f(left, top),     Vec2f(uvs.left_top.u, uvs.left_top.v));
 
    // indices
    init_data.add_triangle(0, 1, 2);
    init_data.add_triangle(2, 3, 0);
 
    GLModel model;
    model.init_from(std::move(init_data));
 
    GLShaderProgram* shader = wxGetApp().get_shader("flat_texture");
    if (shader != nullptr) {
        shader->start_using();
        shader->set_uniform("view_model_matrix", Transform3d::Identity());
        shader->set_uniform("projection_matrix", Transform3d::Identity());
        model.render();
        shader->stop_using();
    }
 
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
 
    glsafe(::glDisable(GL_BLEND));
}

References Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::GUI::GLModel::Geometry::format, GL_BLEND, GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_TEXTURE_2D, glBindTexture, glBlendFuncSeparate, glDisable, glEnable, glsafe, Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::GLTexture::Quad_UVs::left_bottom, Slic3r::GUI::GLTexture::Quad_UVs::left_top, Slic3r::GUI::GLModel::Geometry::P2T2, Slic3r::GUI::GLModel::render(), Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::GUI::GLTexture::Quad_UVs::right_bottom, Slic3r::GUI::GLTexture::Quad_UVs::right_top, Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), Slic3r::GLShaderProgram::stop_using(), Slic3r::GUI::GLModel::Geometry::Triangles, Slic3r::GUI::GLTexture::UV::u, and Slic3r::GUI::GLTexture::UV::v.

Referenced by Slic3r::GUI::GLGizmosManager::do_render_overlay(), Slic3r::GUI::GLToolbarItem::render(), Slic3r::GUI::GLGizmosManager::render_arrow(), Slic3r::GUI::GLToolbar::render_arrow(), Slic3r::GUI::GLGizmosManager::render_background(), Slic3r::GUI::GLToolbar::render_background(), Slic3r::GUI::GLToolbarItem::render_image(), Slic3r::GUI::GLToolbarItem::render_text(), and render_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

render_texture()

void Slic3r::GUI::GLTexture::render_texture ( unsigned int tex_id, float left, float right, float bottom, float top )

static

{
    render_sub_texture(tex_id, left, right, bottom, top, FullTextureUVs);
}

References FullTextureUVs, and render_sub_texture().

Here is the call graph for this function:

reset()

void Slic3r::GUI::GLTexture::reset

(

)

{
    if (m_id != 0)
        glsafe(::glDeleteTextures(1, &m_id));
 
    m_id = 0;
    m_width = 0;
    m_height = 0;
    m_source = "";
    m_compressor.reset();
 
    //BBS: GUI refactor
    m_original_width = m_original_height = 0;
}

References glDeleteTextures, glsafe, m_compressor, m_height, m_id, m_original_height, m_original_width, m_source, and m_width.

Referenced by ~GLTexture(), load_from_file(), load_from_png(), load_from_raw_data(), load_from_svg(), load_from_svg_file(), load_from_svg_files_as_sprites_array(), and Slic3r::GUI::GLTexture::Compressor::send_compressed_data_to_gpu().

Here is the caller graph for this function:

send_compressed_data_to_gpu()

void Slic3r::GUI::GLTexture::send_compressed_data_to_gpu ( )

inline

{ m_compressor.send_compressed_data_to_gpu(); }

References m_compressor.

Referenced by Slic3r::GUI::PartPlate::render_logo_texture().

Here is the caller graph for this function:

unsent_compressed_data_available()

bool Slic3r::GUI::GLTexture::unsent_compressed_data_available ( ) const

inline

{ return m_compressor.unsent_compressed_data_available(); }

References m_compressor.

Referenced by Slic3r::GUI::PartPlate::render_logo_texture().

Here is the caller graph for this function:

Friends And Related Symbol Documentation

Compressor

friend class Compressor

friend

Member Data Documentation

FullTextureUVs

GLTexture::Quad_UVs Slic3r::GUI::GLTexture::FullTextureUVs = { { 0.0f, 1.0f }, { 1.0f, 1.0f }, { 1.0f, 0.0f }, { 0.0f, 0.0f } }

static

Referenced by render_texture().

m_compressor

Compressor Slic3r::GUI::GLTexture::m_compressor

protected

Referenced by GLTexture(), all_compressed_data_sent_to_gpu(), load_from_png(), load_from_svg(), reset(), send_compressed_data_to_gpu(), and unsent_compressed_data_available().

m_height

int Slic3r::GUI::GLTexture::m_height { 0 }

protected

{ 0 };

Referenced by generate_from_text(), generate_texture_from_text(), get_height(), load_from_png(), load_from_raw_data(), load_from_svg(), load_from_svg_files_as_sprites_array(), and reset().

m_id

unsigned int Slic3r::GUI::GLTexture::m_id { 0 }

protected

{ 0 };

Referenced by generate_from_text(), generate_texture_from_text(), get_id(), load_from_png(), load_from_raw_data(), load_from_svg(), load_from_svg_files_as_sprites_array(), and reset().

m_original_height

int Slic3r::GUI::GLTexture::m_original_height

Referenced by generate_from_text(), generate_texture_from_text(), and reset().

m_original_width

int Slic3r::GUI::GLTexture::m_original_width

Referenced by Slic3r::GUI::PartPlate::calc_vertex_for_plate_name_edit_icon(), generate_from_text(), generate_texture_from_text(), get_original_width(), and reset().

m_source

std::string Slic3r::GUI::GLTexture::m_source

protected

Referenced by get_source(), load_from_png(), load_from_svg(), load_from_svg_files_as_sprites_array(), and reset().

m_width

int Slic3r::GUI::GLTexture::m_width { 0 }

protected

{ 0 };

Referenced by generate_from_text(), generate_texture_from_text(), get_width(), load_from_png(), load_from_raw_data(), load_from_svg(), load_from_svg_files_as_sprites_array(), and reset().

---

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

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