Slic3r::GUI::IconManager Class Reference

Keep texture with icons for UI Manage texture live -> create and destruct texture by live of icon shared pointers. More...

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

Collaboration diagram for Slic3r::GUI::IconManager:

Classes
struct	InitType
struct	Icon
	Data for render texture with icon. More...

Public Types
enum class	RasterType : int { color = 1 << 1 , white_only_data = 1 << 2 , gray_only_data = 1 << 3 , color_wite_gray = color | white_only_data | gray_only_data }
	Define way to convert svg data to raster. More...
using	InitTypes = std::vector<InitType>
using	Icons = std::vector<std::shared_ptr<Icon> >
using	VIcons = std::vector<Icons>

Public Member Functions
	~IconManager ()
	Release texture Set shared pointers to invalid texture.
Icons	init (const InitTypes &input)
	Initialize raster texture on GPU with given images NOTE: Have to be called after OpenGL initialization.
VIcons	init (const std::vector< std::string > &file_paths, const ImVec2 &size, RasterType type=RasterType::color)
	Initialize multiple icons with same settings for size and type NOTE: Have to be called after OpenGL initialization.
void	release ()
	Release icons which are hold only by this manager May change texture and position of icons.

Private Attributes
GLTexture	m_icons_texture
unsigned int	m_id { 0 }
Icons	m_icons

Detailed Description

Keep texture with icons for UI Manage texture live -> create and destruct texture by live of icon shared pointers.

---

Class Documentation

Slic3r::GUI::IconManager::InitType

struct Slic3r::GUI::IconManager::InitType

Collaboration diagram for Slic3r::GUI::IconManager::InitType:

Class Members
string	filepath
ImVec2	size
RasterType	type = RasterType::color

Member Typedef Documentation

Icons

using Slic3r::GUI::IconManager::Icons = std::vector<std::shared_ptr<Icon> >

InitTypes

using Slic3r::GUI::IconManager::InitTypes = std::vector<InitType>

VIcons

using Slic3r::GUI::IconManager::VIcons = std::vector<Icons>

Member Enumeration Documentation

RasterType

enum class Slic3r::GUI::IconManager::RasterType : int

strong

Define way to convert svg data to raster.

Enumerator
color
white_only_data
gray_only_data
color_wite_gray

                         : int{
        color           = 1 << 1, 
        white_only_data = 1 << 2, 
        gray_only_data  = 1 << 3,
        color_wite_gray = color | white_only_data | gray_only_data
        // TODO: add type with backgrounds
    };

Constructor & Destructor Documentation

~IconManager()

IconManager::~IconManager

(

)

Release texture Set shared pointers to invalid texture.

                          {
  priv::clear(m_icons);
  // release opengl texture is made in ~GLTexture()
 
    if (m_id != 0)
        glsafe(::glDeleteTextures(1, &m_id));
}

References priv::clear(), glDeleteTextures, glsafe, m_icons, and m_id.

Here is the call graph for this function:

Member Function Documentation

init() [1/2]

IconManager::Icons IconManager::init

(

const InitTypes &

input

)

Initialize raster texture on GPU with given images NOTE: Have to be called after OpenGL initialization.

Parameters

input

Define files and its size with rasterization

Returns

Rasterized icons stored on GPU, Same size and order as input, each item of vector is set of texture in order by RasterType

{
    assert(!input.empty());
    if (input.empty())
        return {};
 
    // TODO: remove in future
    if (m_id != 0) {
        glsafe(::glDeleteTextures(1, &m_id));
        m_id = 0;
    }
 
    int total_surface = 0;
    for (const InitType &i : input)
        total_surface += i.size.x * i.size.y;
    const int surface_sqrt = (int)sqrt((float)total_surface) + 1;
 
    // Start packing
    // Pack our extra data rectangles first, so it will be on the upper-left corner of our texture (UV will have small values).
    const int TEX_HEIGHT_MAX = 1024 * 32;
    int width = (surface_sqrt >= 4096 * 0.7f) ? 4096 : (surface_sqrt >= 2048 * 0.7f) ? 2048 : (surface_sqrt >= 1024 * 0.7f) ? 1024 : 512;
 
    int num_nodes = width;
    std::vector<stbrp_node> nodes(num_nodes);
    stbrp_context context;
    stbrp_init_target(&context, width, TEX_HEIGHT_MAX, nodes.data(), num_nodes);
 
    ImVector<stbrp_rect> pack_rects;
    pack_rects.resize(input.size());
    memset(pack_rects.Data, 0, (size_t) pack_rects.size_in_bytes());
    for (size_t i = 0; i < input.size(); i++) {
        const ImVec2 &size = input[i].size;
        assert(size.x > 1);
        assert(size.y > 1);
        pack_rects[i].w = size.x;
        pack_rects[i].h = size.y;
    }
    int pack_rects_res = stbrp_pack_rects(&context, &pack_rects[0], pack_rects.Size);
    assert(pack_rects_res == 1);
    if (pack_rects_res != 1)
        return {};
 
    ImVec2 tex_size(width, width);
    for (const stbrp_rect &rect : pack_rects) {
        float x = rect.x + rect.w;
        float y = rect.y + rect.h;
        if(x > tex_size.x) tex_size.x = x;
        if(y > tex_size.y) tex_size.y = y;
    }
    
    Icons result(input.size());
    for (int i = 0; i < pack_rects.Size; i++) {
        const stbrp_rect &rect = pack_rects[i];
        assert(rect.was_packed);
        if (!rect.was_packed)
            return {};
 
        ImVec2 tl(rect.x / tex_size.x, rect.y / tex_size.y);
        ImVec2 br((rect.x + rect.w) / tex_size.x, (rect.y + rect.h) / tex_size.y);
 
        assert(input[i].size.x == rect.w);
        assert(input[i].size.y == rect.h);
        Icon icon = {input[i].size, tl, br};
        result[i] = std::make_shared<Icon>(std::move(icon));
    }
        
    NSVGrasterizer *rast = nsvgCreateRasterizer();
    assert(rast != nullptr);
    if (rast == nullptr)
        return {};
    ScopeGuard sg_rast([rast]() { ::nsvgDeleteRasterizer(rast); });
 
    int channels = 4;
    int n_pixels = tex_size.x * tex_size.y;
    // store data for whole texture
    std::vector<unsigned char> data(n_pixels * channels, {0});
 
    // initialize original index locations
    std::vector<size_t> idx(input.size());
    std::iota(idx.begin(), idx.end(), 0);
 
    // Group same filename by sort inputs
    // sort indexes based on comparing values in input
    std::sort(idx.begin(), idx.end(), [&input](size_t i1, size_t i2) { return input[i1].filepath < input[i2].filepath; });
    for (size_t j: idx) {
        const InitType &i = input[j];
        if (i.filepath.empty())
            continue; // no file path only reservation of space for texture
        assert(boost::filesystem::exists(i.filepath));
        if (!boost::filesystem::exists(i.filepath))
            continue;
        assert(boost::algorithm::iends_with(i.filepath, ".svg"));
        if (!boost::algorithm::iends_with(i.filepath, ".svg"))
            continue;
 
        NSVGimage *image = parse_file(i.filepath.c_str());
        assert(image != nullptr);
        if (image == nullptr)
            return {};
 
        ScopeGuard sg_image([image]() { ::nsvgDelete(image); });
 
        float svg_scale = i.size.y / image->height;
        // scale should be same in both directions
        assert(is_approx(svg_scale, i.size.y / image->width));
                
        const stbrp_rect &rect = pack_rects[j];
        int n_pixels = rect.w * rect.h;
        std::vector<unsigned char> icon_data(n_pixels * channels, {0});
        ::nsvgRasterize(rast, image, 0, 0, svg_scale, icon_data.data(), i.size.x, i.size.y, i.size.x * channels);
        
        // makes white or gray only data in icon
        if (i.type == RasterType::white_only_data || 
            i.type == RasterType::gray_only_data) {
            unsigned char value = (i.type == RasterType::white_only_data) ? 255 : 127;
            for (size_t k = 0; k < icon_data.size(); k += channels)
                if (icon_data[k] != 0 || icon_data[k + 1] != 0 || icon_data[k + 2] != 0) {
                    icon_data[k]     = value;
                    icon_data[k + 1] = value;
                    icon_data[k + 2] = value;
                }
        }
 
        int start_offset = (rect.y*tex_size.x + rect.x) * channels;
        int data_stride = tex_size.x * channels;
        subdata(data.data() + start_offset, data_stride, icon_data, rect.w * channels);
    }
 
    if (m_id != 0) 
        glsafe(::glDeleteTextures(1, &m_id));
 
    glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
    glsafe(::glGenTextures(1, &m_id));
    glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint) m_id));
    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(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei) tex_size.x, (GLsizei) tex_size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE,  (const void*) data.data()));    
 
    // bind no texture
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
 
    for (const auto &i : result)
        i->tex_id = m_id;
    return result;
}

References Slic3r::GUI::IconManager::InitType::filepath, 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, glDeleteTextures, glGenTextures, glPixelStorei, glsafe, glTexImage2D, glTexParameteri, gray_only_data, Slic3r::is_approx(), m_id, Slic3r::GUI::IconManager::InitType::size, Slic3r::GUI::IconManager::InitType::type, and white_only_data.

Referenced by anonymous_namespace{GLGizmoSVG.cpp}::init_icons().

Here is the call graph for this function:

Here is the caller graph for this function:

init() [2/2]

std::vector< IconManager::Icons > IconManager::init	(	const std::vector< std::string > &	file_paths,
		const ImVec2 &	size,
		RasterType	type = RasterType::color )

Initialize multiple icons with same settings for size and type NOTE: Have to be called after OpenGL initialization.

Parameters

file_paths	Define files with icon
size	Size of stored texture[in px], float will be rounded
type	Define way to rasterize icon, together color, white and gray = RasterType::color | RasterType::white_only_data | RasterType::gray_only_data

Returns

Rasterized icons stored on GPU, Same size and order as file_paths, each item of vector is set of texture in order by RasterType

{
    assert(!file_paths.empty());
    assert(size.x >= 1);
    assert(size.x < 256*16);
 
    // TODO: remove in future
    if (!m_icons.empty()) {
        // not first initialization
        priv::clear(m_icons);
        m_icons.clear();
        m_icons_texture.reset();
    }
 
    // only rectangle are supported
    assert(size.x == size.y);
    // no subpixel supported
    unsigned int width = static_cast<unsigned int>(std::abs(std::round(size.x)));
    assert(size.x == static_cast<float>(width));
 
    // state order has to match the enum IconState
    const auto& states = priv::get_states(type);
        
    bool compress  = false;
    bool is_loaded = m_icons_texture.load_from_svg_files_as_sprites_array(file_paths, states, width, compress);
    if (!is_loaded || (size_t) m_icons_texture.get_width() < (states.size() * width) ||
        (size_t) m_icons_texture.get_height() < (file_paths.size() * width)) {
        // bad load of icons, but all usage of m_icons_texture check that texture is initialized
        assert(false);
        m_icons_texture.reset();
        return {};
    }
 
    unsigned count_files = file_paths.size();
    // count icons per file
    unsigned count = states.size();
    // create result
    std::vector<Icons> result;
    result.reserve(count_files);
 
    Icon def_icon;
    def_icon.tex_id = m_icons_texture.get_id();
    def_icon.size   = size;
 
    // float beacouse of dividing
    float tex_height = static_cast<float>(m_icons_texture.get_height());
    float tex_width = static_cast<float>(m_icons_texture.get_width());
 
    //for (const auto &f: file_paths) {
    for (unsigned f = 0; f < count_files; ++f) {
        // NOTE: there are space between icons
        unsigned start_y = static_cast<unsigned>(f) * (width + 1) + 1;
        float y1 = start_y / tex_height;
        float y2 = (start_y + width) / tex_height;
        Icons file_icons;
        file_icons.reserve(count);
        //for (const auto &s : states) {
        for (unsigned j = 0; j < count; ++j) {
            auto icon = std::make_shared<Icon>(def_icon);
            // NOTE: there are space between icons
            unsigned start_x = static_cast<unsigned>(j) * (width + 1) + 1;
            float x1 = start_x / tex_width;
            float x2 = (start_x + width) / tex_width;
            icon->tl = ImVec2(x1, y1);
            icon->br = ImVec2(x2, y2);
            file_icons.push_back(icon);
            m_icons.push_back(std::move(icon));
        }
        result.emplace_back(std::move(file_icons));
    }
  return result;
}

References priv::clear(), count, Slic3r::f(), priv::get_states(), m_icons, m_icons_texture, Slic3r::GUI::IconManager::Icon::size, and Slic3r::GUI::IconManager::Icon::tex_id.

Here is the call graph for this function:

release()

void IconManager::release

(

)

Release icons which are hold only by this manager May change texture and position of icons.

                          {
  BOOST_LOG_TRIVIAL(error) << "Not implemented yet";
}

Referenced by anonymous_namespace{GLGizmoSVG.cpp}::init_icons().

Here is the caller graph for this function:

Member Data Documentation

m_icons

Icons Slic3r::GUI::IconManager::m_icons

private

Referenced by ~IconManager(), and init().

m_icons_texture

GLTexture Slic3r::GUI::IconManager::m_icons_texture

private

Referenced by init().

m_id

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

private

{ 0 };

Referenced by ~IconManager(), and init().

---

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

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