Use texture compression on GPU

src/libslic3r/Technologies.hpp

@@ -12,7 +12,7 @@
 // Renders a small sphere in the center of the bounding box of the current selection when no gizmo is active
 #define ENABLE_RENDER_SELECTION_CENTER 0
 // Shows an imgui dialog with render related data
-#define ENABLE_RENDER_STATISTICS 0
+#define ENABLE_RENDER_STATISTICS 1
 
 
 //====================
@@ -46,4 +46,8 @@
 #define ENABLE_SVG_ICONS (1 && ENABLE_1_42_0_ALPHA8 && ENABLE_TEXTURES_FROM_SVG)
 
 
+// Enable saving textures on GPU in compressed format 
+#define ENABLE_COMPRESSED_TEXTURES 1
+
+
 #endif // _technologies_h_

src/slic3r/GUI/GLCanvas3D.cpp

@@ -864,7 +864,14 @@ bool GLCanvas3D::WarningTexture::_generate(const std::string& msg_utf8, const GL
     glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
     glsafe(::glGenTextures(1, &m_id));
     glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)m_id));
+#if ENABLE_COMPRESSED_TEXTURES
+    if (GLEW_EXT_texture_compression_s3tc)
+        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+    else
+        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+#else
     glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+#endif // ENABLE_COMPRESSED_TEXTURES
     glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
     glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
     glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
@@ -1147,7 +1154,14 @@ bool GLCanvas3D::LegendTexture::generate(const GCodePreviewData& preview_data, c
     glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
     glsafe(::glGenTextures(1, &m_id));
     glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)m_id));
+#if ENABLE_COMPRESSED_TEXTURES
+    if (GLEW_EXT_texture_compression_s3tc)
+        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+    else
+        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+#else
     glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+#endif // ENABLE_COMPRESSED_TEXTURES
     glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
     glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
     glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
@@ -1691,11 +1705,17 @@ void GLCanvas3D::render()
     ImGuiWrapper& imgui = *wxGetApp().imgui();
     imgui.set_next_window_bg_alpha(0.5f);
     imgui.begin(std::string("Render statistics"), ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
-    imgui.text(_(L("Last frame")) +": ");
+    imgui.text("Last frame: ");
     ImGui::SameLine();
     imgui.text(std::to_string(m_render_stats.last_frame));
     ImGui::SameLine();
-    imgui.text(" "+_(L("ms")));
+    imgui.text("  ms");
+#if ENABLE_COMPRESSED_TEXTURES
+    ImGui::Separator();
+    imgui.text("Textures: ");
+    ImGui::SameLine();
+    imgui.text(GLCanvas3DManager::are_compressed_textures_supported() ? "Compressed" : "Uncompressed");
+#endif // ENABLE_COMPRESSED_TEXTURES
     imgui.end();
 #endif // ENABLE_RENDER_STATISTICS
 

src/slic3r/GUI/GLCanvas3DManager.cpp

@@ -111,6 +111,9 @@ std::string GLCanvas3DManager::GLInfo::to_string(bool format_as_html, bool exten
 }
 
 GLCanvas3DManager::EMultisampleState GLCanvas3DManager::s_multisample = GLCanvas3DManager::MS_Unknown;
+#if ENABLE_COMPRESSED_TEXTURES
+bool GLCanvas3DManager::s_compressed_textures_supported = false;
+#endif // ENABLE_COMPRESSED_TEXTURES
 
 GLCanvas3DManager::GLCanvas3DManager()
     : m_context(nullptr)
@@ -134,7 +137,7 @@ bool GLCanvas3DManager::add(wxGLCanvas* canvas, Bed3D& bed, Camera& camera, GLTo
     if (canvas == nullptr)
         return false;
 
-    if (_get_canvas(canvas) != m_canvases.end())
+    if (do_get_canvas(canvas) != m_canvases.end())
         return false;
 
     GLCanvas3D* canvas3D = new GLCanvas3D(canvas, bed, camera, view_toolbar);
@@ -159,7 +162,7 @@ bool GLCanvas3DManager::add(wxGLCanvas* canvas, Bed3D& bed, Camera& camera, GLTo
 
 bool GLCanvas3DManager::remove(wxGLCanvas* canvas)
 {
-    CanvasesMap::iterator it = _get_canvas(canvas);
+    CanvasesMap::iterator it = do_get_canvas(canvas);
     if (it == m_canvases.end())
         return false;
 
@@ -195,6 +198,12 @@ void GLCanvas3DManager::init_gl()
         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;
+#if ENABLE_COMPRESSED_TEXTURES
+        if (GLEW_EXT_texture_compression_s3tc)
+            s_compressed_textures_supported = true;
+        else
+            s_compressed_textures_supported = false;
+#endif // ENABLE_COMPRESSED_TEXTURES
     }
 }
 
@@ -205,16 +214,16 @@ std::string GLCanvas3DManager::get_gl_info(bool format_as_html, bool extensions)
 
 bool GLCanvas3DManager::init(wxGLCanvas* canvas)
 {
-    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    CanvasesMap::const_iterator it = do_get_canvas(canvas);
     if (it != m_canvases.end())
-        return (it->second != nullptr) ? _init(*it->second) : false;
+        return (it->second != nullptr) ? init(*it->second) : false;
     else
         return false;
 }
 
 GLCanvas3D* GLCanvas3DManager::get_canvas(wxGLCanvas* canvas)
 {
-    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    CanvasesMap::const_iterator it = do_get_canvas(canvas);
     return (it != m_canvases.end()) ? it->second : nullptr;
 }
 
@@ -224,29 +233,28 @@ wxGLCanvas* GLCanvas3DManager::create_wxglcanvas(wxWindow *parent)
 
     if (s_multisample == MS_Unknown)
     {
-        _detect_multisample(attribList);
+        detect_multisample(attribList);
-        // debug output
+//        // debug output
-        std::cout << "Multisample " << (can_multisample() ? "enabled" : "disabled") << std::endl;
+//        std::cout << "Multisample " << (can_multisample() ? "enabled" : "disabled") << std::endl;
     }
 
-    if (! can_multisample()) {
+    if (! can_multisample())
         attribList[4] = 0;
-    }
 
     return new wxGLCanvas(parent, wxID_ANY, attribList, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS);
 }
 
-GLCanvas3DManager::CanvasesMap::iterator GLCanvas3DManager::_get_canvas(wxGLCanvas* canvas)
+GLCanvas3DManager::CanvasesMap::iterator GLCanvas3DManager::do_get_canvas(wxGLCanvas* canvas)
 {
     return (canvas == nullptr) ? m_canvases.end() : m_canvases.find(canvas);
 }
 
-GLCanvas3DManager::CanvasesMap::const_iterator GLCanvas3DManager::_get_canvas(wxGLCanvas* canvas) const
+GLCanvas3DManager::CanvasesMap::const_iterator GLCanvas3DManager::do_get_canvas(wxGLCanvas* canvas) const
 {
     return (canvas == nullptr) ? m_canvases.end() : m_canvases.find(canvas);
 }
 
-bool GLCanvas3DManager::_init(GLCanvas3D& canvas)
+bool GLCanvas3DManager::init(GLCanvas3D& canvas)
 {
     if (!m_gl_initialized)
         init_gl();
@@ -254,7 +262,7 @@ bool GLCanvas3DManager::_init(GLCanvas3D& canvas)
     return canvas.init(m_use_VBOs, m_use_legacy_opengl);
 }
 
-void GLCanvas3DManager::_detect_multisample(int* attribList)
+void GLCanvas3DManager::detect_multisample(int* attribList)
 {
     int wxVersion = wxMAJOR_VERSION * 10000 + wxMINOR_VERSION * 100 + wxRELEASE_NUMBER;
     const AppConfig* app_config = GUI::get_app_config();

src/slic3r/GUI/GLCanvas3DManager.hpp

@@ -60,6 +60,9 @@ class GLCanvas3DManager
     bool m_use_legacy_opengl;
     bool m_use_VBOs;
     static EMultisampleState s_multisample;
+#if ENABLE_COMPRESSED_TEXTURES
+    static bool s_compressed_textures_supported;
+#endif // ENABLE_COMPRESSED_TEXTURES
 
 public:
     GLCanvas3DManager();
@@ -79,14 +82,18 @@ public:
     GLCanvas3D* get_canvas(wxGLCanvas* canvas);
 
     static bool can_multisample() { return s_multisample == MS_Enabled; }
+#if ENABLE_COMPRESSED_TEXTURES
+    static bool are_compressed_textures_supported() { return s_compressed_textures_supported; }
+#endif // ENABLE_COMPRESSED_TEXTURES
+
     static wxGLCanvas* create_wxglcanvas(wxWindow *parent);
 
 private:
-    CanvasesMap::iterator _get_canvas(wxGLCanvas* canvas);
+    CanvasesMap::iterator do_get_canvas(wxGLCanvas* canvas);
-    CanvasesMap::const_iterator _get_canvas(wxGLCanvas* canvas) const;
+    CanvasesMap::const_iterator do_get_canvas(wxGLCanvas* canvas) const;
 
-    bool _init(GLCanvas3D& canvas);
+    bool init(GLCanvas3D& canvas);
-    static void _detect_multisample(int* attribList);
+    static void detect_multisample(int* attribList);
 };
 
 } // namespace GUI

src/slic3r/GUI/GLTexture.cpp

@@ -178,7 +178,14 @@ bool GLTexture::load_from_svg_files_as_sprites_array(const std::vector<std::stri
     glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
     glsafe(::glGenTextures(1, &m_id));
     glsafe(::glBindTexture(GL_TEXTURE_2D, m_id));
+#if ENABLE_COMPRESSED_TEXTURES
+    if (GLEW_EXT_texture_compression_s3tc)
+        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+    else
+        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+#else
     glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+#endif // ENABLE_COMPRESSED_TEXTURES
     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));
@@ -284,7 +291,14 @@ unsigned int GLTexture::generate_mipmaps(wxImage& image)
             data[data_id + 3] = (img_alpha != nullptr) ? img_alpha[i] : 255;
         }
 
+#if ENABLE_COMPRESSED_TEXTURES
+        if (GLEW_EXT_texture_compression_s3tc)
+            glsafe(::glTexImage2D(GL_TEXTURE_2D, level, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)w, (GLsizei)h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+        else
+            glsafe(::glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, (GLsizei)w, (GLsizei)h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+#else
         glsafe(::glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, (GLsizei)w, (GLsizei)h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+#endif // ENABLE_COMPRESSED_TEXTURES
     }
 
     return (unsigned int)level;
@@ -335,7 +349,14 @@ bool GLTexture::load_from_png(const std::string& filename, bool use_mipmaps)
     glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
     glsafe(::glGenTextures(1, &m_id));
     glsafe(::glBindTexture(GL_TEXTURE_2D, m_id));
+#if ENABLE_COMPRESSED_TEXTURES
+    if (GLEW_EXT_texture_compression_s3tc)
+        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+    else
+        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+#else
     glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+#endif // ENABLE_COMPRESSED_TEXTURES
     if (use_mipmaps)
     {
         // we manually generate mipmaps because glGenerateMipmap() function is not reliable on all graphics cards
@@ -397,7 +418,14 @@ bool GLTexture::load_from_svg(const std::string& filename, bool use_mipmaps, uns
     glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
     glsafe(::glGenTextures(1, &m_id));
     glsafe(::glBindTexture(GL_TEXTURE_2D, m_id));
+#if ENABLE_COMPRESSED_TEXTURES
+    if (GLEW_EXT_texture_compression_s3tc)
+        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+    else
+        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+#else
     glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+#endif // ENABLE_COMPRESSED_TEXTURES
     if (use_mipmaps)
     {
         // we manually generate mipmaps because glGenerateMipmap() function is not reliable on all graphics cards
@@ -413,7 +441,14 @@ bool GLTexture::load_from_svg(const std::string& filename, bool use_mipmaps, uns
             scale /= 2.0f;
 
             nsvgRasterize(rast, image, 0, 0, scale, data.data(), lod_w, lod_h, lod_w * 4);
+#if ENABLE_COMPRESSED_TEXTURES
+            if (GLEW_EXT_texture_compression_s3tc)
+                glsafe(::glTexImage2D(GL_TEXTURE_2D, level, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, (GLsizei)lod_w, (GLsizei)lod_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+            else
+                glsafe(::glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, (GLsizei)lod_w, (GLsizei)lod_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+#else
             glsafe(::glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, (GLsizei)lod_w, (GLsizei)lod_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data()));
+#endif // ENABLE_COMPRESSED_TEXTURES
         }
 
         glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, level));

src/slic3r/GUI/ImGuiWrapper.cpp

@@ -373,7 +373,14 @@ void ImGuiWrapper::init_font()
     glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
     glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
     glsafe(::glPixelStorei(GL_UNPACK_ROW_LENGTH, 0));
+#if ENABLE_COMPRESSED_TEXTURES
+    if (GLEW_EXT_texture_compression_s3tc)
+        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
+    else
+        glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
+#else
     glsafe(::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
+#endif // ENABLE_COMPRESSED_TEXTURES
 
     // Store our identifier
     io.Fonts->TexID = (ImTextureID)(intptr_t)m_font_texture;