Slic3r::GUI::OpenGLManager Class Reference

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

Collaboration diagram for Slic3r::GUI::OpenGLManager:

Classes
class	GLInfo

Public Types
enum class	EFramebufferType : unsigned char { Unknown , Arb , Ext }

Public Member Functions
	OpenGLManager ()=default
	~OpenGLManager ()
bool	init_gl (bool popup_error=true)
wxGLContext *	init_glcontext (wxGLCanvas &canvas, const std::pair< int, int > &required_opengl_version, bool enable_compatibility_profile, bool enable_debug)
GLShaderProgram *	get_shader (const std::string &shader_name)
GLShaderProgram *	get_current_shader ()

Static Public Member Functions
static bool	are_compressed_textures_supported ()
static bool	can_multisample ()
static bool	are_framebuffers_supported ()
static EFramebufferType	get_framebuffers_type ()
static wxGLCanvas *	create_wxglcanvas (wxWindow &parent)
static bool	is_scene_canvas (const wxWindow *window)
static const GLInfo &	get_gl_info ()
static bool	force_power_of_two_textures ()

Private Types
enum class	EMultisampleState : unsigned char { Unknown , Enabled , Disabled }

Static Private Member Functions
static void	detect_multisample (int *attribList)

Private Attributes
bool	m_gl_initialized { false }
wxGLContext *	m_context { nullptr }
GLShadersManager	m_shaders_manager

Static Private Attributes
static GLInfo	s_gl_info
static bool	s_compressed_textures_supported = false
static bool	s_force_power_of_two_textures = false
static EMultisampleState	s_multisample = OpenGLManager::EMultisampleState::Unknown
static EFramebufferType	s_framebuffers_type = OpenGLManager::EFramebufferType::Unknown

Detailed Description

Member Enumeration Documentation

EFramebufferType

enum class Slic3r::GUI::OpenGLManager::EFramebufferType : unsigned char

strong

Enumerator
Unknown
Arb
Ext

    {
        Unknown,
        Arb,
        Ext
    };

EMultisampleState

enum class Slic3r::GUI::OpenGLManager::EMultisampleState : unsigned char

strongprivate

Enumerator
Unknown
Enabled
Disabled

    {
        Unknown,
        Enabled,
        Disabled
    };

Constructor & Destructor Documentation

OpenGLManager()

Slic3r::GUI::OpenGLManager::OpenGLManager ( )

default

~OpenGLManager()

Slic3r::GUI::OpenGLManager::~OpenGLManager

(

)

{
    m_shaders_manager.shutdown();
 
    if (m_context != nullptr)
        delete m_context;
}

References m_context, and m_shaders_manager.

Member Function Documentation

are_compressed_textures_supported()

bool Slic3r::GUI::OpenGLManager::are_compressed_textures_supported ( )

inlinestatic

{ return s_compressed_textures_supported; }

References s_compressed_textures_supported.

Referenced by Slic3r::GUI::GLCanvas3D::_render_frame(), Slic3r::GUI::Emboss::StyleManager::create_imgui_font(), Slic3r::GUI::GLTexture::generate_from_text(), Slic3r::GUI::GLTexture::generate_texture_from_text(), Slic3r::GUI::GLTexture::load_from_png(), Slic3r::GUI::GLTexture::load_from_svg(), and Slic3r::GUI::GLTexture::load_from_svg_files_as_sprites_array().

Here is the caller graph for this function:

are_framebuffers_supported()

bool Slic3r::GUI::OpenGLManager::are_framebuffers_supported ( )

inlinestatic

{ return (s_framebuffers_type != EFramebufferType::Unknown); }

References s_framebuffers_type, and Unknown.

can_multisample()

bool Slic3r::GUI::OpenGLManager::can_multisample ( )

inlinestatic

{ return s_multisample == EMultisampleState::Enabled; }

References Enabled, and s_multisample.

Referenced by Slic3r::GUI::DesignCanvas::DesignCanvas(), create_wxglcanvas(), Slic3r::GUI::anonymous_namespace{UVEditorCanvas.cpp}::gl_attrib_list(), Slic3r::GUI::AssembleView::init(), Slic3r::GUI::Preview::init(), Slic3r::GUI::View3D::init(), Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(), and Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer_ext().

Here is the caller graph for this function:

create_wxglcanvas()

wxGLCanvas * Slic3r::GUI::OpenGLManager::create_wxglcanvas ( wxWindow & parent )

static

{
    int antialiasing_samples = 4;
    if (const AppConfig* app_config = get_app_config(); app_config != nullptr) {
        const std::string value = app_config->get(SETTING_OPENGL_AA_SAMPLES);
        if (value == "0" || value == "2" || value == "4" || value == "8" || value == "16")
            antialiasing_samples = ::atoi(value.c_str());
    }
 
    int attribList[] = {
        WX_GL_RGBA,
        WX_GL_DOUBLEBUFFER,
        // RGB channels each should be allocated with 8 bit depth. One should almost certainly get these bit depths by default.
        WX_GL_MIN_RED,      8,
        WX_GL_MIN_GREEN,    8,
        WX_GL_MIN_BLUE,     8,
        // Requesting an 8 bit alpha channel. Interestingly, the NVIDIA drivers would most likely work with some alpha plane, but glReadPixels would not return
        // the alpha channel on NVIDIA if not requested when the GL context is created.
        WX_GL_MIN_ALPHA,    8,
        WX_GL_DEPTH_SIZE,     24,
        //BBS: turn on stencil buffer for outline
        WX_GL_STENCIL_SIZE,     8,
        WX_GL_SAMPLE_BUFFERS,   antialiasing_samples > 0 ? GL_TRUE : GL_FALSE,
      WX_GL_SAMPLES,      antialiasing_samples,
        0
    };
 
    constexpr int sample_buffers_value_idx = 15;
    constexpr int samples_value_idx        = 17;
 
    if (antialiasing_samples <= 0)
        s_multisample = EMultisampleState::Disabled;
    else if (s_multisample == EMultisampleState::Unknown) {
        detect_multisample(attribList);
//        // debug output
//        std::cout << "Multisample " << (can_multisample() ? "enabled" : "disabled") << std::endl;
    }
 
    if (! can_multisample()) {
        attribList[sample_buffers_value_idx] = GL_FALSE;
        attribList[samples_value_idx] = 0;
    }
 
    wxGLCanvas* canvas = new wxGLCanvas(&parent, wxID_ANY, attribList, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS, SCENE_CANVAS_NAME);
    // The GL canvas paints its entire surface, so background erasing is unnecessary.
    canvas->SetBackgroundStyle(wxBG_STYLE_PAINT);
    return canvas;
}

References can_multisample(), detect_multisample(), Disabled, Slic3r::GUI::get_app_config(), GL_FALSE, GL_TRUE, s_multisample, Slic3r::GUI::SCENE_CANVAS_NAME, SETTING_OPENGL_AA_SAMPLES, and Unknown.

Referenced by Slic3r::GUI::DesignCanvas::DesignCanvas(), Slic3r::GUI::AssembleView::init(), Slic3r::GUI::Preview::init(), and Slic3r::GUI::View3D::init().

Here is the call graph for this function:

Here is the caller graph for this function:

detect_multisample()

void Slic3r::GUI::OpenGLManager::detect_multisample ( int * attribList )

staticprivate

{
    int wxVersion = wxMAJOR_VERSION * 10000 + wxMINOR_VERSION * 100 + wxRELEASE_NUMBER;
    bool enable_multisample = wxVersion >= 30003;
 
#if defined(__WXGTK__)
    // On Wayland, wxGLCanvas::IsDisplaySupported() requires the EGL backend.
    // If wxWidgets was built without EGL, the GLX backend will crash trying
    // to access a non-existent X11 display. Disable multisample in that case.
    if (is_running_on_wayland()) {
#if !defined(wxHAS_EGL) || !wxHAS_EGL
        BOOST_LOG_TRIVIAL(warning) << "Wayland without EGL: disabling multisample detection";
        s_multisample = EMultisampleState::Disabled;
        return;
#endif
    }
#endif
 
    s_multisample =
        enable_multisample &&
        // Disable multi-sampling on ChromeOS, as the OpenGL virtualization swaps Red/Blue channels with multi-sampling enabled,
        // at least on some platforms.
        platform_flavor() != PlatformFlavor::LinuxOnChromium &&
        wxGLCanvas::IsDisplaySupported(attribList)
        ? EMultisampleState::Enabled : EMultisampleState::Disabled;
    // Alternative method: it was working on previous version of wxWidgets but not with the latest, at least on Windows
    // s_multisample = enable_multisample && wxGLCanvas::IsExtensionSupported("WGL_ARB_multisample");
}

References Disabled, Enabled, Slic3r::LinuxOnChromium, Slic3r::platform_flavor(), and s_multisample.

Referenced by create_wxglcanvas().

Here is the call graph for this function:

Here is the caller graph for this function:

force_power_of_two_textures()

bool Slic3r::GUI::OpenGLManager::force_power_of_two_textures ( )

inlinestatic

{ return s_force_power_of_two_textures; }

References s_force_power_of_two_textures.

Referenced by Slic3r::GUI::GLTexture::load_from_png(), and Slic3r::GUI::GLTexture::load_from_svg().

Here is the caller graph for this function:

get_current_shader()

GLShaderProgram * Slic3r::GUI::OpenGLManager::get_current_shader ( )

inline

{ return m_shaders_manager.get_current_shader(); }

References m_shaders_manager.

get_framebuffers_type()

EFramebufferType Slic3r::GUI::OpenGLManager::get_framebuffers_type ( )

inlinestatic

{ return s_framebuffers_type; }

References s_framebuffers_type.

Referenced by Slic3r::GUI::GLCanvas3D::_rectangular_selection_picking_pass(), Slic3r::GUI::GLCanvas3D::_render_shadows(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::GUI::GLCanvas3D::render_thumbnail(), Slic3r::GUI::GLCanvas3D::render_thumbnail(), Slic3r::GLVolume::render_with_outline(), and Slic3r::CLI::run().

Here is the caller graph for this function:

get_gl_info()

const GLInfo & Slic3r::GUI::OpenGLManager::get_gl_info ( )

inlinestatic

{ return s_gl_info; }

References s_gl_info.

Referenced by Slic3r::GUI::GLCanvas3D::_render_frame(), Slic3r::GUI::GLCanvas3D::_render_wireframe_overlay(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::export_3mf_copy(), Slic3r::GUI::TriangleSelectorPatch::finalize_triangle_indices(), Slic3r::GUI::GLMmSegmentationGizmo3DScene::finalize_vertices(), Slic3r::GUI::PartPlateList::generate_icon_textures(), Slic3r::GUI::generate_system_info_json(), Slic3r::GUI::GUI_App::get_gl_info(), Slic3r::GUI::TroubleshootDialog::GetGPUinfo(), Slic3r::anonymous_namespace{PluginHostApp.cpp}::gl_info(), Slic3r::GLShadersManager::init(), Slic3r::GUI::GLCanvas3D::LayersEditing::init(), init_gl(), Slic3r::GUI::GLTexture::load_from_png(), Slic3r::GUI::GLTexture::load_from_raw_data(), Slic3r::GUI::GLTexture::load_from_svg(), Slic3r::GUI::logo_texture_size(), Slic3r::GUI::GLGizmoMove3D::on_render(), Slic3r::GUI::GLGizmoRotate::on_render(), Slic3r::GUI::GLGizmoScale3D::on_render(), Slic3r::GUI::GLGizmoSimplify::on_render(), Slic3r::GUI::GLMmSegmentationGizmo3DScene::release_geometry(), Slic3r::GUI::TriangleSelectorPatch::release_geometry(), Slic3r::GLVolumeCollection::render(), Slic3r::GUI::GLMmSegmentationGizmo3DScene::render(), Slic3r::GUI::GLModel::render(), Slic3r::GUI::GLSelectionRectangle::render(), Slic3r::GUI::TriangleSelectorPatch::render(), Slic3r::GUI::GLGizmoTextureDisplacement::render_adjust_texture_gizmo(), Slic3r::GUI::Selection::render_bounding_box(), Slic3r::GUI::GLGizmoBase::render_cross_mark(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_circle(), Slic3r::GUI::GLGizmoPainterBase::render_cursor_height_range(), Slic3r::GUI::GLGizmoMeasure::render_dimensioning(), Slic3r::GUI::ImGuiWrapper::render_draw_data(), Slic3r::GUI::GLGizmoScale3D::render_grabbers_connection(), Slic3r::GUI::PartPlate::render_grid(), Slic3r::GUI::PartPlate::render_height_limit(), Slic3r::GUI::GLModel::render_instanced(), Slic3r::GUI::TriangleSelectorGUI::render_paint_contour(), Slic3r::GUI::GLCanvas3D::LayersEditing::render_profile(), Slic3r::GUI::GLGizmoTextureDisplacement::render_seam_overlay(), Slic3r::GUI::anonymous_namespace{SceneBenchmark.cpp}::SceneBenchmarkDialog::report(), Slic3r::GUI::DesignCanvas::request_repaint(), Slic3r::GUI::GLModel::reset(), and Slic3r::GUI::GLModel::send_to_gpu().

Here is the caller graph for this function:

get_shader()

GLShaderProgram * Slic3r::GUI::OpenGLManager::get_shader ( const std::string & shader_name )

inline

{ return m_shaders_manager.get_shader(shader_name); }

References m_shaders_manager.

Referenced by Slic3r::CLI::run().

Here is the caller graph for this function:

init_gl()

bool Slic3r::GUI::OpenGLManager::init_gl

(

bool

popup_error = true

)

{
    if (!m_gl_initialized) {
        int version = 0;
#if defined(__WXGTK__) && defined(wxHAS_EGL)
        if (is_running_on_wayland()) {
            // On EGL/Wayland, gladLoaderLoadGL() dlopen's libGL.so then
            // immediately dlclose's it. Since nothing else holds libGL.so
            // open (unlike GLX where the context keeps it loaded), the
            // library gets unmapped and all function pointers become invalid.
            // Use eglGetProcAddress directly to avoid this.
            version = gladLoadGL((GLADloadfunc)eglGetProcAddress);
        } else
#endif
        {
            version = gladLoaderLoadGL();
        }
        if (version == 0) {
            BOOST_LOG_TRIVIAL(error) << "Unable to init GLAD OpenGL loader";
            return false;
        }
        BOOST_LOG_TRIVIAL(info) << "GLAD loaded OpenGL " << GLAD_VERSION_MAJOR(version) << "." << GLAD_VERSION_MINOR(version);
        m_gl_initialized = true;
        if (GLAD_GL_EXT_texture_compression_s3tc)
            s_compressed_textures_supported = true;
        else
            s_compressed_textures_supported = false;
 
        if (s_gl_info.is_version_greater_or_equal_to(3, 0)) {
            // ARB framebuffer became a mandatory part of core OpenGL 3.0
            s_framebuffers_type = EFramebufferType::Arb;
            BOOST_LOG_TRIVIAL(info) << "Opengl version >= 30, FrameBuffer Type ARB." << std::endl;
        }
        else if (GLAD_GL_ARB_framebuffer_object) {
            s_framebuffers_type = EFramebufferType::Arb;
            BOOST_LOG_TRIVIAL(info) << "Found Framebuffer Type ARB."<< std::endl;
        }
        else if (GLAD_GL_EXT_framebuffer_object) {
            BOOST_LOG_TRIVIAL(info) << "Found Framebuffer Type Ext."<< std::endl;
            s_framebuffers_type = EFramebufferType::Ext;
        }
        else {
            s_framebuffers_type = EFramebufferType::Unknown;
            BOOST_LOG_TRIVIAL(warning) << "Found Framebuffer Type unknown!"<< std::endl;
        }
 
        bool valid_version = s_gl_info.is_version_greater_or_equal_to(2, 0);
        if (!valid_version) {
            BOOST_LOG_TRIVIAL(error) << "Found opengl version < 2.0"<< std::endl;
            // Complain about the OpenGL version.
            if (popup_error) {
                wxString message = from_u8((boost::format(
                    _utf8(L("The application cannot run normally because OpenGL version is lower than 3.2.\n")))).str());
                message += "\n";
                message += _L("Please upgrade your graphics card driver.");
                wxMessageBox(message, _L("Unsupported OpenGL version"), wxOK | wxICON_ERROR);
            }
        }
 
        if (valid_version)
        {
            // load shaders
            auto [result, error] = m_shaders_manager.init();
            if (!result) {
                BOOST_LOG_TRIVIAL(error) << "Unable to load shaders: "<<error<< std::endl;
                if (popup_error) {
                    wxString message = from_u8((boost::format(
                        _utf8(L("Unable to load shaders:\n%s"))) % error).str());
                    wxMessageBox(message, _L("Error loading shaders"), wxOK | wxICON_ERROR);
                }
            }
        }
 
#ifdef _WIN32
        // Since AMD driver version 22.7.1, there is probably some bug in the driver that causes the issue with the missing
        // texture of the bed (see: https://github.com/prusa3d/PrusaSlicer/issues/8417).
        // It seems that this issue only triggers when mipmaps are generated manually
        // (combined with a texture compression) with texture size not being power of two.
        // When mipmaps are generated through OpenGL function glGenerateMipmap() the driver works fine,
        // but the mipmap generation is quite slow on some machines.
        // There is no an easy way to detect the driver version without using Win32 API because the strings returned by OpenGL
        // have no standardized format, only some of them contain the driver version.
        // Until we do not know that driver will be fixed (if ever) we force the use of power of two textures on all cards
        // 1) containing the string 'Radeon' in the string returned by glGetString(GL_RENDERER)
        // 2) containing the string 'Custom' in the string returned by glGetString(GL_RENDERER)
        const auto& gl_info = OpenGLManager::get_gl_info();
        if (boost::contains(gl_info.get_vendor(), "ATI Technologies Inc.") &&
           (boost::contains(gl_info.get_renderer(), "Radeon") ||
            boost::contains(gl_info.get_renderer(), "Custom")))
            s_force_power_of_two_textures = true;
#endif // _WIN32
    }
 
    return true;
}

References _L, _utf8, Arb, Ext, Slic3r::GUI::from_u8(), get_gl_info(), GLAD_GL_ARB_framebuffer_object, GLAD_GL_EXT_framebuffer_object, GLAD_GL_EXT_texture_compression_s3tc, GLAD_VERSION_MAJOR, GLAD_VERSION_MINOR, gladLoaderLoadGL(), gladLoadGL(), L, m_gl_initialized, m_shaders_manager, s_compressed_textures_supported, s_force_power_of_two_textures, s_framebuffers_type, s_gl_info, and Unknown.

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

init_glcontext()

wxGLContext * Slic3r::GUI::OpenGLManager::init_glcontext	(	wxGLCanvas &	canvas,
		const std::pair< int, int > &	required_opengl_version,
		bool	enable_compatibility_profile,
		bool	enable_debug )

{
    if (m_context == nullptr) {
        // m_debug_enabled = enable_debug;
 
        const int gl_major = required_opengl_version.first;
        const int gl_minor = required_opengl_version.second;
        const bool supports_core_profile =
            std::find(OpenGLVersions::core.begin(), OpenGLVersions::core.end(), std::make_pair(gl_major, gl_minor)) != OpenGLVersions::core.end();
 
        if (gl_major == 0 && !enable_compatibility_profile) {
            // search for highest supported core profile version
            // disable wxWidgets logging to avoid showing the log dialog in case the following code fails generating a valid gl context
            wxLogNull logNo;
            for (auto v = OpenGLVersions::core.rbegin(); v != OpenGLVersions::core.rend(); ++v) {
                wxGLContextAttrs attrs;
                attrs.PlatformDefaults().MajorVersion(v->first).MinorVersion(v->second).CoreProfile().ForwardCompatible();
                // if (m_debug_enabled)
                //     attrs.DebugCtx();
                attrs.EndList();
                m_context = new wxGLContext(&canvas, nullptr, &attrs);
                if (m_context->IsOK())
                    break;
                else {
                    delete m_context;
                    m_context = nullptr;
                }
            }
        }
 
        if (m_context == nullptr) {
            // search for requested compatibility profile version
            if (enable_compatibility_profile) {
                // disable wxWidgets logging to avoid showing the log dialog in case the following code fails generating a valid gl context
                wxLogNull logNo;
                wxGLContextAttrs attrs;
                attrs.PlatformDefaults().CompatibilityProfile();
                // if (m_debug_enabled)
                //     attrs.DebugCtx();
                attrs.EndList();
                m_context = new wxGLContext(&canvas, nullptr, &attrs);
                if (!m_context->IsOK()) {
                    delete m_context;
                    m_context = nullptr;
                }
            }
            // search for requested core profile version
            else if (supports_core_profile) {
                // disable wxWidgets logging to avoid showing the log dialog in case the following code fails generating a valid gl context
                wxLogNull logNo;
                wxGLContextAttrs attrs;
                attrs.PlatformDefaults().MajorVersion(gl_major).MinorVersion(gl_minor).CoreProfile().ForwardCompatible();
                // if (m_debug_enabled)
                //     attrs.DebugCtx();
                attrs.EndList();
                m_context = new wxGLContext(&canvas, nullptr, &attrs);
                if (!m_context->IsOK()) {
                    delete m_context;
                    m_context = nullptr;
                }
            }
        }
 
        if (m_context == nullptr) {
            wxGLContextAttrs attrs;
            attrs.PlatformDefaults();
            // if (m_debug_enabled)
            //     attrs.DebugCtx();
            attrs.EndList();
            // if no valid context was created use the default one
            m_context = new wxGLContext(&canvas, nullptr, &attrs);
        }
 
    }
    return m_context;
}

References Slic3r::GUI::OpenGLVersions::core, and m_context.

is_scene_canvas()

bool Slic3r::GUI::OpenGLManager::is_scene_canvas ( const wxWindow * window )

static

{
    return window != nullptr && window->GetName() == SCENE_CANVAS_NAME;
}

References Slic3r::GUI::SCENE_CANVAS_NAME.

Referenced by Slic3r::GUI::anonymous_namespace{MainFrame.cpp}::focused_canvas_imgui().

Here is the caller graph for this function:

Member Data Documentation

m_context

wxGLContext* Slic3r::GUI::OpenGLManager::m_context { nullptr }

private

{ nullptr };

Referenced by ~OpenGLManager(), and init_glcontext().

m_gl_initialized

bool Slic3r::GUI::OpenGLManager::m_gl_initialized { false }

private

{ false };

Referenced by init_gl().

m_shaders_manager

GLShadersManager Slic3r::GUI::OpenGLManager::m_shaders_manager

private

Referenced by ~OpenGLManager(), get_current_shader(), get_shader(), and init_gl().

s_compressed_textures_supported

bool Slic3r::GUI::OpenGLManager::s_compressed_textures_supported = false

staticprivate

Referenced by are_compressed_textures_supported(), and init_gl().

s_force_power_of_two_textures

bool Slic3r::GUI::OpenGLManager::s_force_power_of_two_textures = false

staticprivate

Referenced by force_power_of_two_textures(), and init_gl().

s_framebuffers_type

OpenGLManager::EFramebufferType Slic3r::GUI::OpenGLManager::s_framebuffers_type = OpenGLManager::EFramebufferType::Unknown

staticprivate

Referenced by are_framebuffers_supported(), get_framebuffers_type(), and init_gl().

s_gl_info

OpenGLManager::GLInfo Slic3r::GUI::OpenGLManager::s_gl_info

staticprivate

Referenced by get_gl_info(), and init_gl().

s_multisample

OpenGLManager::EMultisampleState Slic3r::GUI::OpenGLManager::s_multisample = OpenGLManager::EMultisampleState::Unknown

staticprivate

Referenced by can_multisample(), create_wxglcanvas(), and detect_multisample().

---

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

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