GitHub-Proxy/PrusaSlicer
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/prusa3d/PrusaSlicer.git synced 2025-08-16 15:35:55 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

libvgcode - refactoring of class OpenGLWrapper

Browse Source
This commit is contained in:
enricoturri1966 2024-02-26 15:57:51 +01:00 committed by Lukas Matena
parent 9217141b65
commit 9579c9c212
3 changed files with 49 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/libvgcode/src/OpenGLUtils.cpp
View File

@ -2,6 +2,8 @@
///|/ ///|/
///|/ libvgcode is released under the terms of the AGPLv3 or higher ///|/ libvgcode is released under the terms of the AGPLv3 or higher
///|/ ///|/
#include "../include/Types.hpp"
#include "OpenGLUtils.hpp" #include "OpenGLUtils.hpp"
#include <iostream> #include <iostream>
@ -36,17 +38,17 @@ void glAssertRecentCallImpl(const char* file_name, unsigned int line, const char
static const char* OPENGL_ES_PREFIXES[] = { "OpenGL ES-CM ", "OpenGL ES-CL ", "OpenGL ES ", nullptr }; static const char* OPENGL_ES_PREFIXES[] = { "OpenGL ES-CM ", "OpenGL ES-CL ", "OpenGL ES ", nullptr };
bool OpenGLWrapper::s_valid_context = false;
bool OpenGLWrapper::load_opengl(const std::string& context_version) bool OpenGLWrapper::load_opengl(const std::string& context_version)
{ {
m_valid_context = false; s_valid_context = false;
m_opengl_es = false;
const char* version = context_version.c_str(); const char* version = context_version.c_str();
for (int i = 0; OPENGL_ES_PREFIXES[i] != nullptr; ++i) { for (int i = 0; OPENGL_ES_PREFIXES[i] != nullptr; ++i) {
const size_t length = strlen(OPENGL_ES_PREFIXES[i]); const size_t length = strlen(OPENGL_ES_PREFIXES[i]);
if (strncmp(version, OPENGL_ES_PREFIXES[i], length) == 0) { if (strncmp(version, OPENGL_ES_PREFIXES[i], length) == 0) {
version += length; version += length;
m_opengl_es = true;
break; break;
} }
} }
@ -61,13 +63,21 @@ bool OpenGLWrapper::load_opengl(const std::string& context_version)
if (res != 2) if (res != 2)
return false; return false;
m_valid_context = m_opengl_es ? major > 2 || (major == 2 && minor >= 0) : major > 3 || (major == 3 && minor >= 2); #if VGCODE_ENABLE_OPENGL_ES
s_valid_context = major > 3 || (major == 3 && minor >= 0);
#else
s_valid_context = major > 3 || (major == 3 && minor >= 2);
#endif // VGCODE_ENABLE_OPENGL_ES
const int glad_res = gladLoadGL(); const int glad_res = gladLoadGL();
if (glad_res == 0) if (glad_res == 0)
return false; return false;
return m_valid_context; return s_valid_context;
}
void OpenGLWrapper::unload_opengl()
{
} }
} // namespace libvgcode } // namespace libvgcode

9
src/libvgcode/src/OpenGLUtils.hpp
View File

@ -29,13 +29,12 @@ inline void glAssertRecentCall() { }
class OpenGLWrapper class OpenGLWrapper
{ {
public: public:
bool load_opengl(const std::string& context_version); static bool load_opengl(const std::string& context_version);
bool is_valid_context() { return m_valid_context; } static void unload_opengl();
bool is_opengl_es() { return m_opengl_es; } static bool is_valid_context() { return s_valid_context; }
private: private:
bool m_valid_context{ false }; static bool s_valid_context;
bool m_opengl_es{ false };
}; };
} // namespace libvgcode } // namespace libvgcode

49
src/libvgcode/src/ViewerImpl.cpp
View File

@ -321,22 +321,24 @@ void ViewerImpl::init(const std::string& opengl_context_version)
if (m_initialized) if (m_initialized)
return; return;
OpenGLWrapper opengl_wrapper; if (!OpenGLWrapper::load_opengl(opengl_context_version)) {
if (!opengl_wrapper.load_opengl(opengl_context_version)) { if (OpenGLWrapper::is_valid_context())
if (opengl_wrapper.is_valid_context())
throw std::runtime_error("LibVGCode was unable to initialize the GLAD library.\n"); throw std::runtime_error("LibVGCode was unable to initialize the GLAD library.\n");
else { else {
if (opengl_wrapper.is_opengl_es()) #if VGCODE_ENABLE_OPENGL_ES
throw std::runtime_error("LibVGCode requires an OpenGL ES context based on OpenGL ES 2.0 or higher.\n"); throw std::runtime_error("LibVGCode requires an OpenGL ES context based on OpenGL ES 3.0 or higher.\n");
else #else
throw std::runtime_error("LibVGCode requires an OpenGL context based on OpenGL 3.2 or higher.\n"); throw std::runtime_error("LibVGCode requires an OpenGL context based on OpenGL 3.2 or higher.\n");
#endif // VGCODE_ENABLE_OPENGL_ES
} }
} }
// segments shader // segments shader
m_segments_shader_id = opengl_wrapper.is_opengl_es() ? #if VGCODE_ENABLE_OPENGL_ES
init_shader("segments", Segments_Vertex_Shader_ES, Segments_Fragment_Shader_ES) : m_segments_shader_id = init_shader("segments", Segments_Vertex_Shader_ES, Segments_Fragment_Shader_ES);
init_shader("segments", Segments_Vertex_Shader, Segments_Fragment_Shader); #else
m_segments_shader_id = init_shader("segments", Segments_Vertex_Shader, Segments_Fragment_Shader);
#endif // VGCODE_ENABLE_OPENGL_ES
m_uni_segments_view_matrix_id = glGetUniformLocation(m_segments_shader_id, "view_matrix"); m_uni_segments_view_matrix_id = glGetUniformLocation(m_segments_shader_id, "view_matrix");
m_uni_segments_projection_matrix_id = glGetUniformLocation(m_segments_shader_id, "projection_matrix"); m_uni_segments_projection_matrix_id = glGetUniformLocation(m_segments_shader_id, "projection_matrix");
@ -357,9 +359,11 @@ void ViewerImpl::init(const std::string& opengl_context_version)
m_segment_template.init(); m_segment_template.init();
// options shader // options shader
m_options_shader_id = opengl_wrapper.is_opengl_es() ? #if VGCODE_ENABLE_OPENGL_ES
init_shader("options", Options_Vertex_Shader_ES, Options_Fragment_Shader_ES) : m_options_shader_id = init_shader("options", Options_Vertex_Shader_ES, Options_Fragment_Shader_ES);
init_shader("options", Options_Vertex_Shader, Options_Fragment_Shader); #else
m_options_shader_id = init_shader("options", Options_Vertex_Shader, Options_Fragment_Shader);
#endif // VGCODE_ENABLE_OPENGL_ES
m_uni_options_view_matrix_id = glGetUniformLocation(m_options_shader_id, "view_matrix"); m_uni_options_view_matrix_id = glGetUniformLocation(m_options_shader_id, "view_matrix");
m_uni_options_projection_matrix_id = glGetUniformLocation(m_options_shader_id, "projection_matrix"); m_uni_options_projection_matrix_id = glGetUniformLocation(m_options_shader_id, "projection_matrix");
@ -379,9 +383,11 @@ void ViewerImpl::init(const std::string& opengl_context_version)
#if VGCODE_ENABLE_COG_AND_TOOL_MARKERS #if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
// cog marker shader // cog marker shader
m_cog_marker_shader_id = opengl_wrapper.is_opengl_es() ? #if VGCODE_ENABLE_OPENGL_ES
init_shader("cog_marker", Cog_Marker_Vertex_Shader_ES, Cog_Marker_Fragment_Shader_ES) : m_cog_marker_shader_id = init_shader("cog_marker", Cog_Marker_Vertex_Shader_ES, Cog_Marker_Fragment_Shader_ES);
init_shader("cog_marker", Cog_Marker_Vertex_Shader, Cog_Marker_Fragment_Shader); #else
m_cog_marker_shader_id = init_shader("cog_marker", Cog_Marker_Vertex_Shader, Cog_Marker_Fragment_Shader);
#endif // VGCODE_ENABLE_OPENGL_ES
m_uni_cog_marker_world_center_position = glGetUniformLocation(m_cog_marker_shader_id, "world_center_position"); m_uni_cog_marker_world_center_position = glGetUniformLocation(m_cog_marker_shader_id, "world_center_position");
m_uni_cog_marker_scale_factor = glGetUniformLocation(m_cog_marker_shader_id, "scale_factor"); m_uni_cog_marker_scale_factor = glGetUniformLocation(m_cog_marker_shader_id, "scale_factor");
@ -396,9 +402,11 @@ void ViewerImpl::init(const std::string& opengl_context_version)
m_cog_marker.init(32, 1.0f); m_cog_marker.init(32, 1.0f);
// tool marker shader // tool marker shader
m_tool_marker_shader_id = opengl_wrapper.is_opengl_es() ? #if VGCODE_ENABLE_OPENGL_ES
init_shader("tool_marker", Tool_Marker_Vertex_Shader_ES, Tool_Marker_Fragment_Shader_ES) : m_tool_marker_shader_id = init_shader("tool_marker", Tool_Marker_Vertex_Shader_ES, Tool_Marker_Fragment_Shader_ES);
init_shader("tool_marker", Tool_Marker_Vertex_Shader, Tool_Marker_Fragment_Shader); #else
m_tool_marker_shader_id = init_shader("tool_marker", Tool_Marker_Vertex_Shader, Tool_Marker_Fragment_Shader);
#endif // VGCODE_ENABLE_OPENGL_ES
m_uni_tool_marker_world_origin = glGetUniformLocation(m_tool_marker_shader_id, "world_origin"); m_uni_tool_marker_world_origin = glGetUniformLocation(m_tool_marker_shader_id, "world_origin");
m_uni_tool_marker_scale_factor = glGetUniformLocation(m_tool_marker_shader_id, "scale_factor"); m_uni_tool_marker_scale_factor = glGetUniformLocation(m_tool_marker_shader_id, "scale_factor");
@ -437,6 +445,7 @@ void ViewerImpl::shutdown()
m_segments_shader_id = 0; m_segments_shader_id = 0;
} }
m_initialized = false; m_initialized = false;
OpenGLWrapper::unload_opengl();
} }
void ViewerImpl::reset() void ViewerImpl::reset()
@ -576,8 +585,8 @@ void ViewerImpl::load(GCodeInputData&& gcode_data)
position[2] -= 0.5f * v.height; position[2] -= 0.5f * v.height;
positions.emplace_back(position); positions.emplace_back(position);
const float angle = std::atan2(prev_line[0] * this_line[1] - prev_line[1] * this_line[0], dot(prev_line, this_line)); heights_widths_angles.push_back({ v.height, v.width,
heights_widths_angles.push_back({ v.height, v.width, angle }); std::atan2(prev_line[0] * this_line[1] - prev_line[1] * this_line[0], dot(prev_line, this_line)) });
} }
m_positions_tex_size = positions.size() * sizeof(Vec3); m_positions_tex_size = positions.size() * sizeof(Vec3);