OpenGL info moved to c++

lib/Slic3r/GUI.pm

@@ -218,8 +218,12 @@ sub system_info {
     my $opengl_info_txt = '';
     if (defined($self->{mainframe}) && defined($self->{mainframe}->{plater}) &&
         defined($self->{mainframe}->{plater}->{canvas3D})) {
-        $opengl_info = $self->{mainframe}->{plater}->{canvas3D}->opengl_info(format => 'html');
+#==============================================================================================================================
-        $opengl_info_txt = $self->{mainframe}->{plater}->{canvas3D}->opengl_info;
+        $opengl_info = Slic3r::GUI::_3DScene::get_gl_info(1, 1);
+        $opengl_info_txt = Slic3r::GUI::_3DScene::get_gl_info(0, 1);
+#        $opengl_info = $self->{mainframe}->{plater}->{canvas3D}->opengl_info(format => 'html');
+#        $opengl_info_txt = $self->{mainframe}->{plater}->{canvas3D}->opengl_info;
+#==============================================================================================================================
     }
     my $about = Slic3r::GUI::SystemInfo->new(
         parent      => undef, 

lib/Slic3r/GUI/3DScene.pm

@@ -1839,39 +1839,39 @@ sub Render {
 #    my ($self, $config) = @_;    
 #    $self->volumes->update_colors_by_extruder($config);
 #}
+#
+#sub opengl_info
+#{
+#    my ($self, %params) = @_;
+#    my %tag = Slic3r::tags($params{format});
+#
+#    my $gl_version       = glGetString(GL_VERSION);
+#    my $gl_vendor        = glGetString(GL_VENDOR);
+#    my $gl_renderer      = glGetString(GL_RENDERER);
+#    my $glsl_version     = glGetString(GL_SHADING_LANGUAGE_VERSION);
+#
+#    my $out = '';
+#    $out .= "$tag{h2start}OpenGL installation$tag{h2end}$tag{eol}";
+#    $out .= "  $tag{bstart}Using POGL$tag{bend} v$OpenGL::BUILD_VERSION$tag{eol}";
+#    $out .= "  $tag{bstart}GL version:   $tag{bend}${gl_version}$tag{eol}";
+#    $out .= "  $tag{bstart}vendor:       $tag{bend}${gl_vendor}$tag{eol}";
+#    $out .= "  $tag{bstart}renderer:     $tag{bend}${gl_renderer}$tag{eol}";
+#    $out .= "  $tag{bstart}GLSL version: $tag{bend}${glsl_version}$tag{eol}";
+#
+#    # Check for other OpenGL extensions
+#    $out .= "$tag{h2start}Installed extensions (* implemented in the module):$tag{h2end}$tag{eol}";
+#    my $extensions = glGetString(GL_EXTENSIONS);
+#    my @extensions = split(' ',$extensions);
+#    foreach my $ext (sort @extensions) {
+#        my $stat = glpCheckExtension($ext);
+#        $out .= sprintf("%s ${ext}$tag{eol}", $stat?' ':'*');
+#        $out .= sprintf("    ${stat}$tag{eol}") if ($stat && $stat !~ m|^$ext |);
+#    }
+#
+#    return $out;
+#}
 #==============================================================================================================================
 
-sub opengl_info
-{
-    my ($self, %params) = @_;
-    my %tag = Slic3r::tags($params{format});
-
-    my $gl_version       = glGetString(GL_VERSION);
-    my $gl_vendor        = glGetString(GL_VENDOR);
-    my $gl_renderer      = glGetString(GL_RENDERER);
-    my $glsl_version     = glGetString(GL_SHADING_LANGUAGE_VERSION);
-
-    my $out = '';
-    $out .= "$tag{h2start}OpenGL installation$tag{h2end}$tag{eol}";
-    $out .= "  $tag{bstart}Using POGL$tag{bend} v$OpenGL::BUILD_VERSION$tag{eol}";
-    $out .= "  $tag{bstart}GL version:   $tag{bend}${gl_version}$tag{eol}";
-    $out .= "  $tag{bstart}vendor:       $tag{bend}${gl_vendor}$tag{eol}";
-    $out .= "  $tag{bstart}renderer:     $tag{bend}${gl_renderer}$tag{eol}";
-    $out .= "  $tag{bstart}GLSL version: $tag{bend}${glsl_version}$tag{eol}";
-
-    # Check for other OpenGL extensions
-    $out .= "$tag{h2start}Installed extensions (* implemented in the module):$tag{h2end}$tag{eol}";
-    my $extensions = glGetString(GL_EXTENSIONS);
-    my @extensions = split(' ',$extensions);
-    foreach my $ext (sort @extensions) {
-        my $stat = glpCheckExtension($ext);
-        $out .= sprintf("%s ${ext}$tag{eol}", $stat?' ':'*');
-        $out .= sprintf("    ${stat}$tag{eol}") if ($stat && $stat !~ m|^$ext |);
-    }
-
-    return $out;
-}
-
 sub _report_opengl_state
 {
     my ($self, $comment) = @_;

xs/src/slic3r/GUI/3DScene.cpp

@@ -1729,6 +1729,11 @@ void _3DScene::init_gl()
     s_canvas_mgr.init_gl();
 }
 
+std::string _3DScene::get_gl_info(bool format_as_html, bool extensions)
+{
+    return s_canvas_mgr.get_gl_info(format_as_html, extensions);
+}
+
 bool _3DScene::use_VBOs()
 {
     return s_canvas_mgr.use_VBOs();

xs/src/slic3r/GUI/3DScene.hpp

@@ -538,6 +538,7 @@ class _3DScene
 public:
 //##################################################################################################################
     static void init_gl();
+    static std::string get_gl_info(bool format_as_html, bool extensions);
     static bool use_VBOs();
 
     static bool add_canvas(wxGLCanvas* canvas, wxGLContext* context);

xs/src/slic3r/GUI/GLCanvas3DManager.cpp

@@ -17,20 +17,47 @@
 namespace Slic3r {
 namespace GUI {
 
-GLCanvas3DManager::GLVersion::GLVersion()
+GLCanvas3DManager::GLInfo::GLInfo()
-    : vn_major(0)
+    : version("")
-    , vn_minor(0)
+    , glsl_version("")
+    , vendor("")
+    , renderer("")
 {
 }
 
-bool GLCanvas3DManager::GLVersion::detect()
+bool GLCanvas3DManager::GLInfo::detect()
 {
-    const char* gl_version = (const char*)::glGetString(GL_VERSION);
+    const char* data = (const char*)::glGetString(GL_VERSION);
-    if (gl_version == nullptr)
+    if (data == nullptr)
         return false;
 
+    version = data;
+
+    data = (const char*)::glGetString(GL_SHADING_LANGUAGE_VERSION);
+    if (data == nullptr)
+        return false;
+
+    glsl_version = data;
+
+    data = (const char*)::glGetString(GL_VENDOR);
+    if (data == nullptr)
+        return false;
+
+    vendor = data;
+
+    data = (const char*)::glGetString(GL_RENDERER);
+    if (data == nullptr)
+        return false;
+
+    renderer = data;
+
+    return true;
+}
+
+bool GLCanvas3DManager::GLInfo::is_version_greater_or_equal_to(unsigned int major, unsigned int minor) const
+{
     std::vector<std::string> tokens;
-    boost::split(tokens, gl_version, boost::is_any_of(" "), boost::token_compress_on);
+    boost::split(tokens, version, boost::is_any_of(" "), boost::token_compress_on);
 
     if (tokens.empty())
         return false;
@@ -38,23 +65,61 @@ bool GLCanvas3DManager::GLVersion::detect()
     std::vector<std::string> numbers;
     boost::split(numbers, tokens[0], boost::is_any_of("."), boost::token_compress_on);
 
+    unsigned int gl_major = 0;
+    unsigned int gl_minor = 0;
+
     if (numbers.size() > 0)
-        vn_major = ::atoi(numbers[0].c_str());
+        gl_major = ::atoi(numbers[0].c_str());
 
     if (numbers.size() > 1)
-        vn_minor = ::atoi(numbers[1].c_str());
+        gl_minor = ::atoi(numbers[1].c_str());
 
-    return true;
+    if (gl_major < major)
-}
-
-bool GLCanvas3DManager::GLVersion::is_greater_or_equal_to(unsigned int major, unsigned int minor) const
-{
-    if (vn_major < major)
         return false;
-    else if (vn_major > major)
+    else if (gl_major > major)
         return true;
     else
-        return vn_minor >= minor;
+        return gl_minor >= minor;
+}
+
+std::string GLCanvas3DManager::GLInfo::to_string(bool format_as_html, bool extensions) const
+{
+    std::stringstream out;
+
+    std::string h2_start = format_as_html ? "<b>" : "";
+    std::string h2_end   = format_as_html ? "</b>" : "";
+    std::string b_start  = format_as_html ? "<b>" : "";
+    std::string b_end    = format_as_html ? "</b>" : "";
+    std::string line_end = format_as_html ? "<br>" : "\n";
+
+    out << h2_start << "OpenGL installation" << h2_end << line_end;
+    out << b_start  << "GL version:   " << b_end << version << line_end;
+    out << b_start  << "Vendor:       " << b_end << vendor << line_end;
+    out << b_start  << "Renderer:     " << b_end << renderer << line_end;
+    out << b_start  << "GLSL version: " << b_end << glsl_version << line_end;
+
+    if (extensions)
+    {
+        out << h2_start << "Installed extensions:" << h2_end << line_end;
+
+        std::vector<std::string> extensions_list;
+        GLint num_extensions;
+        ::glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
+         
+        for (unsigned int i = 0; i < num_extensions; ++i)
+        {
+            const char* e = (const char*)::glGetStringi(GL_EXTENSIONS, i);
+            extensions_list.push_back(e);
+        }
+
+        std::sort(extensions_list.begin(), extensions_list.end());
+        for (const std::string& ext : extensions_list)
+        {
+            out << ext << line_end;
+        }
+    }
+
+    return out.str();
 }
 
 GLCanvas3DManager::GLCanvas3DManager()
@@ -134,19 +199,27 @@ void GLCanvas3DManager::init_gl()
         std::cout << "GLCanvas3DManager::init_gl()" << std::endl;
 
         glewInit();
-        m_gl_version.detect();
+        if (m_gl_info.detect())
+        {
+            const AppConfig* config = GUI::get_app_config();
+            m_use_legacy_opengl = (config == nullptr) || (config->get("use_legacy_opengl") == "1");
+            m_use_VBOs = !m_use_legacy_opengl && m_gl_info.is_version_greater_or_equal_to(2, 0);
+            m_gl_initialized = true;
 
-        const AppConfig* config = GUI::get_app_config();
+            std::cout << "DETECTED OPENGL: " << m_gl_info.version << std::endl;
-        m_use_legacy_opengl = (config == nullptr) || (config->get("use_legacy_opengl") == "1");
+            std::cout << "USE VBOS = " << (m_use_VBOs ? "YES" : "NO") << std::endl;
-        m_use_VBOs = !m_use_legacy_opengl && m_gl_version.is_greater_or_equal_to(2, 0);
+            std::cout << "LAYER EDITING ALLOWED = " << (!m_use_legacy_opengl ? "YES" : "NO") << std::endl;
-        m_gl_initialized = true;
+        }
-
+        else
-        std::cout << "DETECTED OPENGL: " << m_gl_version.vn_major << "." << m_gl_version.vn_minor << std::endl;
+            throw std::runtime_error(std::string("Unable to initialize OpenGL driver\n"));
-        std::cout << "USE VBOS = " << (m_use_VBOs ? "YES" : "NO") << std::endl;
-        std::cout << "LAYER EDITING ALLOWED = " << (!m_use_legacy_opengl ? "YES" : "NO") << std::endl;
     }
 }
 
+std::string GLCanvas3DManager::get_gl_info(bool format_as_html, bool extensions) const
+{
+    return m_gl_info.to_string(format_as_html, extensions);
+}
+
 bool GLCanvas3DManager::use_VBOs() const
 {
     return m_use_VBOs;

xs/src/slic3r/GUI/GLCanvas3DManager.hpp

@@ -10,21 +10,25 @@ namespace GUI {
 
 class GLCanvas3DManager
 {
-    struct GLVersion
+    struct GLInfo
     {
-        unsigned int vn_major;
+        std::string version;
-        unsigned int vn_minor;
+        std::string glsl_version;
+        std::string vendor;
+        std::string renderer;
+
+        GLInfo();
 
-        GLVersion();
         bool detect();
+        bool is_version_greater_or_equal_to(unsigned int major, unsigned int minor) const;
 
-        bool is_greater_or_equal_to(unsigned int major, unsigned int minor) const;
+        std::string to_string(bool format_as_html, bool extensions) const;
     };
 
     typedef std::map<wxGLCanvas*, GLCanvas3D*> CanvasesMap;
 
     CanvasesMap m_canvases;
-    GLVersion m_gl_version;
+    GLInfo m_gl_info;
     bool m_gl_initialized;
     bool m_use_legacy_opengl;
     bool m_use_VBOs;
@@ -40,6 +44,7 @@ public:
     unsigned int count() const;
 
     void init_gl();
+    std::string get_gl_info(bool format_as_html, bool extensions) const;
 
     bool use_VBOs() const;
     bool layer_editing_allowed() const;

xs/xsp/GUI_3DScene.xsp

@@ -161,6 +161,15 @@ init_gl()
     CODE:
         _3DScene::init_gl();
 
+std::string
+get_gl_info(format_as_html, extensions)
+        bool format_as_html;
+        bool extensions;
+    CODE:
+        RETVAL = _3DScene::get_gl_info(format_as_html, extensions);
+    OUTPUT:
+        RETVAL
+
 bool
 use_VBOs()
     CODE: