3DPrinting/PrusaSlicer-NonPlainar
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

OpenGL info moved to c++

Browse source
This commit is contained in:
Enrico Turri 2018-06-04 10:14:09 +02:00
parent 7d56b38e40
commit 8911cf6051
7 changed files with 162 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
lib/Slic3r/GUI.pm
View file

@ -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,

62
lib/Slic3r/GUI/3DScene.pm
View file

@ -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) = @_;

5
xs/src/slic3r/GUI/3DScene.cpp
View file

@ -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();

1
xs/src/slic3r/GUI/3DScene.hpp
View file

@ -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);

125
xs/src/slic3r/GUI/GLCanvas3DManager.cpp
View file

@ -17,20 +17,47 @@
namespace Slic3r {
namespace GUI {
GLCanvas3DManager::GLVersion::GLVersion()
: vn_major(0)
, vn_minor(0)
GLCanvas3DManager::GLInfo::GLInfo()
: version("")
, glsl_version("")
, vendor("")
, renderer("")
{
}
bool GLCanvas3DManager::GLVersion::detect()
bool GLCanvas3DManager::GLInfo::detect()
{
const char* gl_version = (const char*)::glGetString(GL_VERSION);
if (gl_version == nullptr)
const char* data = (const char*)::glGetString(GL_VERSION);
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;
}
bool GLCanvas3DManager::GLVersion::is_greater_or_equal_to(unsigned int major, unsigned int minor) const
{
if (vn_major < major)
if (gl_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();
m_use_legacy_opengl = (config == nullptr) || (config->get("use_legacy_opengl") == "1");
m_use_VBOs = !m_use_legacy_opengl && m_gl_version.is_greater_or_equal_to(2, 0);
m_gl_initialized = true;
std::cout << "DETECTED OPENGL: " << m_gl_version.vn_major << "." << m_gl_version.vn_minor << std::endl;
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::cout << "DETECTED OPENGL: " << m_gl_info.version << std::endl;
std::cout << "USE VBOS = " << (m_use_VBOs ? "YES" : "NO") << std::endl;
std::cout << "LAYER EDITING ALLOWED = " << (!m_use_legacy_opengl ? "YES" : "NO") << std::endl;
}
else
throw std::runtime_error(std::string("Unable to initialize OpenGL driver\n"));
}
}
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;

17
xs/src/slic3r/GUI/GLCanvas3DManager.hpp
View file

@ -10,21 +10,25 @@ namespace GUI {
class GLCanvas3DManager
{
struct GLVersion
struct GLInfo
{
unsigned int vn_major;
unsigned int vn_minor;
std::string version;
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;

9
xs/xsp/GUI_3DScene.xsp
View file

@ -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: