Printbed textures generated from svg files

resources/shaders/printbed.fs

@@ -0,0 +1,20 @@
+#version 110
+
+const vec3 back_color_dark = vec3(0.235, 0.235, 0.235);
+const vec3 back_color_light = vec3(0.365, 0.365, 0.365);
+
+uniform sampler2D texture;
+uniform bool transparent_background;
+
+varying vec2 tex_coords;
+
+void main()
+{
+    // calculates radial gradient
+    vec3 back_color = vec3(mix(back_color_light, back_color_dark, smoothstep(0.0, 0.5, length(abs(tex_coords.xy) - vec2(0.5)))));
+
+    vec4 fore_color = texture2D(texture, tex_coords);
+
+    // blends foreground with background
+    gl_FragColor = vec4(mix(back_color, fore_color.rgb, fore_color.a), transparent_background ? fore_color.a : 1.0);
+}

resources/shaders/printbed.vs

@@ -0,0 +1,11 @@
+#version 110
+
+attribute vec2 v_tex_coords;
+
+varying vec2 tex_coords;
+
+void main()
+{
+    gl_Position = ftransform();
+    tex_coords = v_tex_coords;
+}

src/libslic3r/Technologies.hpp

@@ -51,4 +51,12 @@
 #define ENABLE_MODE_AWARE_TOOLBAR_ITEMS (1 && ENABLE_1_42_0_ALPHA5)
 
 
+//====================
+// 1.42.0.alpha7 techs
+//====================
+#define ENABLE_1_42_0_ALPHA7 1
+
+// Printbed textures generated from svg files
+#define ENABLE_TEXTURES_FROM_SVG (1 && ENABLE_1_42_0_ALPHA7)
+
 #endif // _technologies_h_

src/slic3r/GUI/3DBed.cpp

@@ -20,6 +20,67 @@ namespace GUI {
 
 bool GeometryBuffer::set_from_triangles(const Polygons& triangles, float z, bool generate_tex_coords)
 {
+#if ENABLE_TEXTURES_FROM_SVG
+    m_vertices.clear();
+    unsigned int v_size = 3 * (unsigned int)triangles.size();
+
+    if (v_size == 0)
+        return false;
+
+    m_vertices = std::vector<Vertex>(v_size, Vertex());
+
+    float min_x = unscale<float>(triangles[0].points[0](0));
+    float min_y = unscale<float>(triangles[0].points[0](1));
+    float max_x = min_x;
+    float max_y = min_y;
+
+    unsigned int v_count = 0;
+    for (const Polygon& t : triangles)
+    {
+        for (unsigned int i = 0; i < 3; ++i)
+        {
+            Vertex& v = m_vertices[v_count];
+
+            const Point& p = t.points[i];
+            float x = unscale<float>(p(0));
+            float y = unscale<float>(p(1));
+
+            v.position[0] = x;
+            v.position[1] = y;
+            v.position[2] = z;
+
+            if (generate_tex_coords)
+            {
+                v.tex_coords[0] = x;
+                v.tex_coords[1] = y;
+
+                min_x = std::min(min_x, x);
+                max_x = std::max(max_x, x);
+                min_y = std::min(min_y, y);
+                max_y = std::max(max_y, y);
+            }
+
+            ++v_count;
+        }
+    }
+
+    if (generate_tex_coords)
+    {
+        float size_x = max_x - min_x;
+        float size_y = max_y - min_y;
+
+        if ((size_x != 0.0f) && (size_y != 0.0f))
+        {
+            float inv_size_x = 1.0f / size_x;
+            float inv_size_y = -1.0f / size_y;
+            for (Vertex& v : m_vertices)
+            {
+                v.tex_coords[0] = (v.tex_coords[0] - min_x) * inv_size_x;
+                v.tex_coords[1] = (v.tex_coords[1] - min_y) * inv_size_y;
+            }
+        }
+    }
+#else
     m_vertices.clear();
     m_tex_coords.clear();
 
@@ -80,12 +141,38 @@ bool GeometryBuffer::set_from_triangles(const Polygons& triangles, float z, bool
             }
         }
     }
+#endif // ENABLE_TEXTURES_FROM_SVG
 
     return true;
 }
 
 bool GeometryBuffer::set_from_lines(const Lines& lines, float z)
 {
+#if ENABLE_TEXTURES_FROM_SVG
+    m_vertices.clear();
+
+    unsigned int v_size = 2 * (unsigned int)lines.size();
+    if (v_size == 0)
+        return false;
+
+    m_vertices = std::vector<Vertex>(v_size, Vertex());
+
+    unsigned int v_count = 0;
+    for (const Line& l : lines)
+    {
+        Vertex& v1 = m_vertices[v_count];
+        v1.position[0] = unscale<float>(l.a(0));
+        v1.position[1] = unscale<float>(l.a(1));
+        v1.position[2] = z;
+        ++v_count;
+
+        Vertex& v2 = m_vertices[v_count];
+        v2.position[0] = unscale<float>(l.b(0));
+        v2.position[1] = unscale<float>(l.b(1));
+        v2.position[2] = z;
+        ++v_count;
+    }
+#else
     m_vertices.clear();
     m_tex_coords.clear();
 
@@ -105,10 +192,18 @@ bool GeometryBuffer::set_from_lines(const Lines& lines, float z)
         m_vertices[coord++] = unscale<float>(l.b(1));
         m_vertices[coord++] = z;
     }
+#endif // ENABLE_TEXTURES_FROM_SVG
 
     return true;
 }
 
+#if ENABLE_TEXTURES_FROM_SVG
+const float* GeometryBuffer::get_vertices_data() const
+{
+    return (m_vertices.size() > 0) ? (const float*)m_vertices.data() : nullptr;
+}
+#endif // ENABLE_TEXTURES_FROM_SVG
+
 const double Bed3D::Axes::Radius = 0.5;
 const double Bed3D::Axes::ArrowBaseRadius = 2.5 * Bed3D::Axes::Radius;
 const double Bed3D::Axes::ArrowLength = 5.0;
@@ -176,8 +271,11 @@ void Bed3D::Axes::render_axis(double length) const
 }
 
 Bed3D::Bed3D()
-: m_type(Custom)
-, m_scale_factor(1.0f)
+    : m_type(Custom)
+#if ENABLE_TEXTURES_FROM_SVG
+    , m_vbo_id(0)
+#endif // ENABLE_TEXTURES_FROM_SVG
+    , m_scale_factor(1.0f)
 {
 }
 
@@ -206,6 +304,10 @@ bool Bed3D::set_shape(const Pointfs& shape)
 
     m_polygon = offset_ex(poly.contour, (float)bed_bbox.radius() * 1.7f, jtRound, scale_(0.5))[0].contour;
 
+#if ENABLE_TEXTURES_FROM_SVG
+    reset();
+#endif // ENABLE_TEXTURES_FROM_SVG
+
     // Set the origin and size for painting of the coordinate system axes.
     m_axes.origin = Vec3d(0.0, 0.0, (double)GROUND_Z);
     m_axes.length = 0.1 * get_bounding_box().max_size() * Vec3d::Ones();
@@ -224,6 +326,39 @@ Point Bed3D::point_projection(const Point& point) const
     return m_polygon.point_projection(point);
 }
 
+#if ENABLE_TEXTURES_FROM_SVG
+void Bed3D::render(float theta, bool useVBOs, float scale_factor) const
+{
+    m_scale_factor = scale_factor;
+
+    EType type = useVBOs ? m_type : Custom;
+    switch (type)
+
+    {
+    case MK2:
+    {
+        render_prusa("mk2", theta > 90.0f);
+        break;
+    }
+    case MK3:
+    {
+        render_prusa("mk3", theta > 90.0f);
+        break;
+    }
+    case SL1:
+    {
+        render_prusa("sl1", theta > 90.0f);
+        break;
+    }
+    default:
+    case Custom:
+    {
+        render_custom();
+        break;
+    }
+    }
+}
+#else
 void Bed3D::render(float theta, bool useVBOs, float scale_factor) const
 {
     m_scale_factor = scale_factor;
@@ -256,6 +391,7 @@ void Bed3D::render(float theta, bool useVBOs, float scale_factor) const
     }
     }
 }
+#endif // ENABLE_TEXTURES_FROM_SVG
 
 void Bed3D::render_axes() const
 {
@@ -349,6 +485,131 @@ Bed3D::EType Bed3D::detect_type(const Pointfs& shape) const
     return type;
 }
 
+#if ENABLE_TEXTURES_FROM_SVG
+void Bed3D::render_prusa(const std::string &key, bool bottom) const
+{
+    std::string tex_path = resources_dir() + "/icons/bed/" + key;
+
+    std::string model_path = resources_dir() + "/models/" + key;
+
+    // use anisotropic filter if graphic card allows
+    GLfloat max_anisotropy = 0.0f;
+    if (glewIsSupported("GL_EXT_texture_filter_anisotropic"))
+        ::glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &max_anisotropy);
+
+    // use higher resolution images if graphic card allows
+    GLint max_tex_size;
+    ::glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_tex_size);
+
+    // clamp or the texture generation becomes too slow
+    max_tex_size = std::min(max_tex_size, 8192);
+
+    std::string filename = tex_path + ".svg";
+
+    if ((m_texture.get_id() == 0) || (m_texture.get_source() != filename))
+    {
+        if (!m_texture.load_from_svg_file(filename, true, max_tex_size))
+        {
+            render_custom();
+            return;
+        }
+
+        if (max_anisotropy > 0.0f)
+        {
+            ::glBindTexture(GL_TEXTURE_2D, m_texture.get_id());
+            ::glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropy);
+            ::glBindTexture(GL_TEXTURE_2D, 0);
+        }
+    }
+
+    if (!bottom)
+    {
+        filename = model_path + "_bed.stl";
+        if ((m_model.get_filename() != filename) && m_model.init_from_file(filename, true)) {
+            Vec3d offset = m_bounding_box.center() - Vec3d(0.0, 0.0, 0.5 * m_model.get_bounding_box().size()(2));
+            if (key == "mk2")
+                // hardcoded value to match the stl model
+                offset += Vec3d(0.0, 7.5, -0.03);
+            else if (key == "mk3")
+                // hardcoded value to match the stl model
+                offset += Vec3d(0.0, 5.5, 2.43);
+            else if (key == "sl1")
+                // hardcoded value to match the stl model
+                offset += Vec3d(0.0, 0.0, -0.03);
+
+            m_model.center_around(offset);
+        }
+
+        if (!m_model.get_filename().empty())
+        {
+            ::glEnable(GL_LIGHTING);
+            m_model.render();
+            ::glDisable(GL_LIGHTING);
+        }
+    }
+
+    unsigned int triangles_vcount = m_triangles.get_vertices_count();
+    if (triangles_vcount > 0)
+    {
+        if (m_vbo_id == 0)
+        {
+            ::glGenBuffers(1, &m_vbo_id);
+            ::glBindBuffer(GL_ARRAY_BUFFER, m_vbo_id);
+            ::glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)m_triangles.get_vertices_data_size(), (const GLvoid*)m_triangles.get_vertices_data(), GL_STATIC_DRAW);
+            ::glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, m_triangles.get_vertex_data_size(), (GLvoid*)m_triangles.get_position_offset());
+            ::glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, m_triangles.get_vertex_data_size(), (GLvoid*)m_triangles.get_tex_coords_offset());
+            ::glBindBuffer(GL_ARRAY_BUFFER, 0);
+        }
+
+        ::glEnable(GL_DEPTH_TEST);
+        ::glDepthMask(GL_FALSE);
+
+        ::glEnable(GL_BLEND);
+        ::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+        ::glEnable(GL_TEXTURE_2D);
+        ::glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+        if (bottom)
+            ::glFrontFace(GL_CW);
+
+        render_prusa_shader(triangles_vcount, bottom);
+
+        if (bottom)
+            ::glFrontFace(GL_CCW);
+
+        ::glDisable(GL_TEXTURE_2D);
+
+        ::glDisable(GL_BLEND);
+        ::glDepthMask(GL_TRUE);
+    }
+}
+
+void Bed3D::render_prusa_shader(unsigned int vertices_count, bool transparent) const
+{
+    if (m_shader.get_shader_program_id() == 0)
+        m_shader.init("printbed.vs", "printbed.fs");
+
+    if (m_shader.is_initialized())
+    {
+        m_shader.start_using();
+        m_shader.set_uniform("transparent_background", transparent);
+
+        ::glBindTexture(GL_TEXTURE_2D, (GLuint)m_texture.get_id());
+        ::glBindBuffer(GL_ARRAY_BUFFER, m_vbo_id);
+        ::glEnableVertexAttribArray(0);
+        ::glEnableVertexAttribArray(1);
+        ::glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vertices_count);
+        ::glDisableVertexAttribArray(1);
+        ::glDisableVertexAttribArray(0);
+        ::glBindBuffer(GL_ARRAY_BUFFER, 0);
+        ::glBindTexture(GL_TEXTURE_2D, 0);
+
+        m_shader.stop_using();
+    }
+}
+
+#else
 void Bed3D::render_prusa(const std::string &key, float theta, bool useVBOs) const
 {
     std::string tex_path = resources_dir() + "/icons/bed/" + key;
@@ -468,11 +729,16 @@ void Bed3D::render_prusa(const std::string &key, float theta, bool useVBOs) cons
         glsafe(::glDepthMask(GL_TRUE));
     }
 }
+#endif // ENABLE_TEXTURES_FROM_SVG
 
 void Bed3D::render_custom() const
 {
+#if ENABLE_TEXTURES_FROM_SVG
+    m_texture.reset();
+#else
     m_top_texture.reset();
     m_bottom_texture.reset();
+#endif // ENABLE_TEXTURES_FROM_SVG
 
     unsigned int triangles_vcount = m_triangles.get_vertices_count();
     if (triangles_vcount > 0)
@@ -487,7 +753,11 @@ void Bed3D::render_custom() const
 
         glsafe(::glColor4f(0.35f, 0.35f, 0.35f, 0.4f));
         glsafe(::glNormal3d(0.0f, 0.0f, 1.0f));
+#if ENABLE_TEXTURES_FROM_SVG
+        ::glVertexPointer(3, GL_FLOAT, m_triangles.get_vertex_data_size(), (GLvoid*)m_triangles.get_vertices_data());
+#else
         glsafe(::glVertexPointer(3, GL_FLOAT, 0, (GLvoid*)m_triangles.get_vertices()));
+#endif // ENABLE_TEXTURES_FROM_SVG
         glsafe(::glDrawArrays(GL_TRIANGLES, 0, (GLsizei)triangles_vcount));
 
         // draw grid
@@ -497,7 +767,11 @@ void Bed3D::render_custom() const
         glsafe(::glEnable(GL_DEPTH_TEST));
         glsafe(::glLineWidth(3.0f * m_scale_factor));
         glsafe(::glColor4f(0.2f, 0.2f, 0.2f, 0.4f));
+#if ENABLE_TEXTURES_FROM_SVG
+        ::glVertexPointer(3, GL_FLOAT, m_triangles.get_vertex_data_size(), (GLvoid*)m_gridlines.get_vertices_data());
+#else
         glsafe(::glVertexPointer(3, GL_FLOAT, 0, (GLvoid*)m_gridlines.get_vertices()));
+#endif // ENABLE_TEXTURES_FROM_SVG
         glsafe(::glDrawArrays(GL_LINES, 0, (GLsizei)gridlines_vcount));
 
         glsafe(::glDisableClientState(GL_VERTEX_ARRAY));
@@ -507,5 +781,16 @@ void Bed3D::render_custom() const
     }
 }
 
+#if ENABLE_TEXTURES_FROM_SVG
+void Bed3D::reset()
+{
+    if (m_vbo_id > 0)
+    {
+        ::glDeleteBuffers(1, &m_vbo_id);
+        m_vbo_id = 0;
+    }
+}
+#endif // ENABLE_TEXTURES_FROM_SVG
+
 } // GUI
 } // Slic3r

src/slic3r/GUI/3DBed.hpp

@@ -3,6 +3,9 @@
 
 #include "GLTexture.hpp"
 #include "3DScene.hpp"
+#if ENABLE_TEXTURES_FROM_SVG
+#include "GLShader.hpp"
+#endif // ENABLE_TEXTURES_FROM_SVG
 
 class GLUquadric;
 typedef class GLUquadric GLUquadricObj;
@@ -12,17 +15,41 @@ namespace GUI {
 
 class GeometryBuffer
 {
+#if ENABLE_TEXTURES_FROM_SVG
+    struct Vertex
+    {
+        float position[3];
+        float tex_coords[2];
+
+        Vertex()
+        {
+            position[0] = 0.0f; position[1] = 0.0f; position[2] = 0.0f;
+            tex_coords[0] = 0.0f; tex_coords[1] = 0.0f;
+        }
+    };
+
+    std::vector<Vertex> m_vertices;
+#else
     std::vector<float> m_vertices;
     std::vector<float> m_tex_coords;
+#endif // ENABLE_TEXTURES_FROM_SVG
 
 public:
     bool set_from_triangles(const Polygons& triangles, float z, bool generate_tex_coords);
     bool set_from_lines(const Lines& lines, float z);
 
+#if ENABLE_TEXTURES_FROM_SVG
+    const float* get_vertices_data() const;
+    unsigned int get_vertices_data_size() const { return (unsigned int)m_vertices.size() * get_vertex_data_size(); }
+    unsigned int get_vertex_data_size() const { return (unsigned int)(5 * sizeof(float)); }
+    unsigned int get_position_offset() const { return 0; }
+    unsigned int get_tex_coords_offset() const { return (unsigned int)(3 * sizeof(float)); }
+    unsigned int get_vertices_count() const { return (unsigned int)m_vertices.size(); }
+#else
     const float* get_vertices() const { return m_vertices.data(); }
     const float* get_tex_coords() const { return m_tex_coords.data(); }
-
     unsigned int get_vertices_count() const { return (unsigned int)m_vertices.size() / 3; }
+#endif // ENABLE_TEXTURES_FROM_SVG
 };
 
 class Bed3D
@@ -62,8 +89,14 @@ private:
     Polygon m_polygon;
     GeometryBuffer m_triangles;
     GeometryBuffer m_gridlines;
+#if ENABLE_TEXTURES_FROM_SVG
+    mutable GLTexture m_texture;
+    mutable Shader m_shader;
+    mutable unsigned int m_vbo_id;
+#else
     mutable GLTexture m_top_texture;
     mutable GLTexture m_bottom_texture;
+#endif // ENABLE_TEXTURES_FROM_SVG
     mutable GLBed m_model;
     Axes m_axes;
 
@@ -71,6 +104,9 @@ private:
 
 public:
     Bed3D();
+#if ENABLE_TEXTURES_FROM_SVG
+    ~Bed3D() { reset(); }
+#endif // ENABLE_TEXTURES_FROM_SVG
 
     EType get_type() const { return m_type; }
 
@@ -93,8 +129,16 @@ private:
     void calc_triangles(const ExPolygon& poly);
     void calc_gridlines(const ExPolygon& poly, const BoundingBox& bed_bbox);
     EType detect_type(const Pointfs& shape) const;
+#if ENABLE_TEXTURES_FROM_SVG
+    void render_prusa(const std::string& key, bool bottom) const;
+    void render_prusa_shader(unsigned int vertices_count, bool transparent) const;
+#else
     void render_prusa(const std::string &key, float theta, bool useVBOs) const;
+#endif // ENABLE_TEXTURES_FROM_SVG
     void render_custom() const;
+#if ENABLE_TEXTURES_FROM_SVG
+    void reset();
+#endif // ENABLE_TEXTURES_FROM_SVG
 };
 
 } // GUI

src/slic3r/GUI/GLCanvas3D.cpp

@@ -238,6 +238,7 @@ void GLCanvas3D::Camera::set_scene_box(const BoundingBoxf3& box, GLCanvas3D& can
     }
 }
 
+#if !ENABLE_TEXTURES_FROM_SVG
 GLCanvas3D::Shader::Shader()
     : m_shader(nullptr)
 {
@@ -316,6 +317,7 @@ void GLCanvas3D::Shader::_reset()
         m_shader = nullptr;
     }
 }
+#endif // !ENABLE_TEXTURES_FROM_SVG
 
 GLCanvas3D::LayersEditing::LayersEditing()
     : m_use_legacy_opengl(false)

src/slic3r/GUI/GLCanvas3D.hpp

@@ -192,6 +192,7 @@ class GLCanvas3D
         void set_scene_box(const BoundingBoxf3& box, GLCanvas3D& canvas);
     };
 
+#if !ENABLE_TEXTURES_FROM_SVG
     class Shader
     {
         GLShader* m_shader;
@@ -215,6 +216,7 @@ class GLCanvas3D
     private:
         void _reset();
     };
+#endif // !ENABLE_TEXTURES_FROM_SVG
 
     class LayersEditing
     {

src/slic3r/GUI/GLShader.cpp

@@ -253,4 +253,91 @@ sub SetMatrix
 }
 */
 
+#if ENABLE_TEXTURES_FROM_SVG
+Shader::Shader()
+    : m_shader(nullptr)
+{
+}
+
+Shader::~Shader()
+{
+    reset();
+}
+
+bool Shader::init(const std::string& vertex_shader_filename, const std::string& fragment_shader_filename)
+{
+    if (is_initialized())
+        return true;
+
+    m_shader = new GLShader();
+    if (m_shader != nullptr)
+    {
+        if (!m_shader->load_from_file(fragment_shader_filename.c_str(), vertex_shader_filename.c_str()))
+        {
+            std::cout << "Compilaton of shader failed:" << std::endl;
+            std::cout << m_shader->last_error << std::endl;
+            reset();
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool Shader::is_initialized() const
+{
+    return (m_shader != nullptr);
+}
+
+bool Shader::start_using() const
+{
+    if (is_initialized())
+    {
+        m_shader->enable();
+        return true;
+    }
+    else
+        return false;
+}
+
+void Shader::stop_using() const
+{
+    if (m_shader != nullptr)
+        m_shader->disable();
+}
+
+void Shader::set_uniform(const std::string& name, float value) const
+{
+    if (m_shader != nullptr)
+        m_shader->set_uniform(name.c_str(), value);
+}
+
+void Shader::set_uniform(const std::string& name, const float* matrix) const
+{
+    if (m_shader != nullptr)
+        m_shader->set_uniform(name.c_str(), matrix);
+}
+
+void Shader::set_uniform(const std::string& name, bool value) const
+{
+    if (m_shader != nullptr)
+        m_shader->set_uniform(name.c_str(), value);
+}
+
+unsigned int Shader::get_shader_program_id() const
+{
+    return (m_shader != nullptr) ? m_shader->shader_program_id : 0;
+}
+
+void Shader::reset()
+{
+    if (m_shader != nullptr)
+    {
+        m_shader->release();
+        delete m_shader;
+        m_shader = nullptr;
+    }
+}
+#endif // ENABLE_TEXTURES_FROM_SVG
+
 } // namespace Slic3r

src/slic3r/GUI/GLShader.hpp

@@ -36,6 +36,34 @@ public:
     std::string     last_error;
 };
 
+#if ENABLE_TEXTURES_FROM_SVG
+class Shader
+{
+    GLShader* m_shader;
+
+public:
+    Shader();
+    ~Shader();
+
+    bool init(const std::string& vertex_shader_filename, const std::string& fragment_shader_filename);
+
+    bool is_initialized() const;
+
+    bool start_using() const;
+    void stop_using() const;
+
+    void set_uniform(const std::string& name, float value) const;
+    void set_uniform(const std::string& name, const float* matrix) const;
+    void set_uniform(const std::string& name, bool value) const;
+
+    const GLShader* get_shader() const { return m_shader; }
+    unsigned int get_shader_program_id() const;
+
+private:
+    void reset();
+};
+#endif // ENABLE_TEXTURES_FROM_SVG
+
 }
 
 #endif /* slic3r_GLShader_hpp_ */

src/slic3r/GUI/GLTexture.cpp

@@ -1,3 +1,4 @@
+#include "libslic3r/libslic3r.h"
 #include "GLTexture.hpp"
 
 #include <GL/glew.h>
@@ -5,10 +6,20 @@
 #include <wx/image.h>
 
 #include <boost/filesystem.hpp>
+#if ENABLE_TEXTURES_FROM_SVG
+#include <boost/algorithm/string/predicate.hpp>
+#endif // ENABLE_TEXTURES_FROM_SVG
 
 #include <vector>
 #include <algorithm>
 
+#if ENABLE_TEXTURES_FROM_SVG
+#define NANOSVG_IMPLEMENTATION
+#include "nanosvg/nanosvg.h"
+#define NANOSVGRAST_IMPLEMENTATION
+#include "nanosvg/nanosvgrast.h"
+#endif // ENABLE_TEXTURES_FROM_SVG
+
 namespace Slic3r {
 namespace GUI {
 
@@ -27,7 +38,34 @@ GLTexture::~GLTexture()
     reset();
 }
 
-bool GLTexture::load_from_file(const std::string& filename, bool generate_mipmaps)
+#if ENABLE_TEXTURES_FROM_SVG
+bool GLTexture::load_from_file(const std::string& filename, bool use_mipmaps)
+{
+    reset();
+
+    if (!boost::filesystem::exists(filename))
+        return false;
+
+    if (boost::algorithm::iends_with(filename, ".png"))
+        return load_from_png(filename, use_mipmaps);
+    else
+        return false;
+}
+
+bool GLTexture::load_from_svg_file(const std::string& filename, bool use_mipmaps, unsigned int max_size_px)
+{
+    reset();
+
+    if (!boost::filesystem::exists(filename))
+        return false;
+
+    if (boost::algorithm::iends_with(filename, ".svg"))
+        return load_from_svg(filename, use_mipmaps, max_size_px);
+    else
+        return false;
+}
+#else
+bool GLTexture::load_from_file(const std::string& filename, bool use_mipmaps)
 {
     reset();
 
@@ -78,10 +116,10 @@ bool GLTexture::load_from_file(const std::string& filename, bool generate_mipmap
     ::glGenTextures(1, &m_id);
     ::glBindTexture(GL_TEXTURE_2D, m_id);
     ::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data());
-    if (generate_mipmaps)
+    if (use_mipmaps)
     {
         // we manually generate mipmaps because glGenerateMipmap() function is not reliable on all graphics cards
-        unsigned int levels_count = _generate_mipmaps(image);
+        unsigned int levels_count = generate_mipmaps(image);
         ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1 + levels_count);
         ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
     }
@@ -97,6 +135,7 @@ bool GLTexture::load_from_file(const std::string& filename, bool generate_mipmap
     m_source = filename;
     return true;
 }
+#endif // ENABLE_TEXTURES_FROM_SVG
 
 void GLTexture::reset()
 {
@@ -109,26 +148,6 @@ void GLTexture::reset()
     m_source = "";
 }
 
-unsigned int GLTexture::get_id() const
-{
-    return m_id;
-}
-
-int GLTexture::get_width() const
-{
-    return m_width;
-}
-
-int GLTexture::get_height() const
-{
-    return m_height;
-}
-
-const std::string& GLTexture::get_source() const
-{
-    return m_source;
-}
-
 void GLTexture::render_texture(unsigned int tex_id, float left, float right, float bottom, float top)
 {
     render_sub_texture(tex_id, left, right, bottom, top, FullTextureUVs);
@@ -157,7 +176,7 @@ void GLTexture::render_sub_texture(unsigned int tex_id, float left, float right,
     ::glDisable(GL_BLEND);
 }
 
-unsigned int GLTexture::_generate_mipmaps(wxImage& image)
+unsigned int GLTexture::generate_mipmaps(wxImage& image)
 {
     int w = image.GetWidth();
     int h = image.GetHeight();
@@ -195,5 +214,152 @@ unsigned int GLTexture::_generate_mipmaps(wxImage& image)
     return (unsigned int)level;
 }
 
+#if ENABLE_TEXTURES_FROM_SVG
+bool GLTexture::load_from_png(const std::string& filename, bool use_mipmaps)
+{
+    // Load a PNG with an alpha channel.
+    wxImage image;
+    if (!image.LoadFile(wxString::FromUTF8(filename.c_str()), wxBITMAP_TYPE_PNG))
+    {
+        reset();
+        return false;
+    }
+
+    m_width = image.GetWidth();
+    m_height = image.GetHeight();
+    int n_pixels = m_width * m_height;
+
+    if (n_pixels <= 0)
+    {
+        reset();
+        return false;
+    }
+
+    // Get RGB & alpha raw data from wxImage, pack them into an array.
+    unsigned char* img_rgb = image.GetData();
+    if (img_rgb == nullptr)
+    {
+        reset();
+        return false;
+    }
+
+    unsigned char* img_alpha = image.GetAlpha();
+
+    std::vector<unsigned char> data(n_pixels * 4, 0);
+    for (int i = 0; i < n_pixels; ++i)
+    {
+        int data_id = i * 4;
+        int img_id = i * 3;
+        data[data_id + 0] = img_rgb[img_id + 0];
+        data[data_id + 1] = img_rgb[img_id + 1];
+        data[data_id + 2] = img_rgb[img_id + 2];
+        data[data_id + 3] = (img_alpha != nullptr) ? img_alpha[i] : 255;
+    }
+
+    // sends data to gpu
+    ::glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    ::glGenTextures(1, &m_id);
+    ::glBindTexture(GL_TEXTURE_2D, m_id);
+    ::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data());
+    if (use_mipmaps)
+    {
+        // we manually generate mipmaps because glGenerateMipmap() function is not reliable on all graphics cards
+        unsigned int levels_count = generate_mipmaps(image);
+        ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1 + levels_count);
+        ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+    }
+    else
+    {
+        ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1);
+    }
+    ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+    ::glBindTexture(GL_TEXTURE_2D, 0);
+
+    m_source = filename;
+
+    return true;
+}
+
+bool GLTexture::load_from_svg(const std::string& filename, bool use_mipmaps, unsigned int max_size_px)
+{
+    NSVGimage* image = nsvgParseFromFile(filename.c_str(), "px", 96.0f);
+    if (image == nullptr)
+    {
+//        printf("Could not open SVG image.\n");
+        reset();
+        return false;
+    }
+
+    float scale = (float)max_size_px / std::max(image->width, image->height);
+
+    m_width = (int)(scale * image->width);
+    m_height = (int)(scale * image->height);
+    int n_pixels = m_width * m_height;
+
+    if (n_pixels <= 0)
+    {
+        reset();
+        return false;
+    }
+
+    NSVGrasterizer* rast = nsvgCreateRasterizer();
+    if (rast == nullptr)
+    {
+//        printf("Could not init rasterizer.\n");
+        nsvgDelete(image);
+        reset();
+        return false;
+    }
+
+    // creates the temporary buffer only once, with max size, and reuse it for all the levels, if generating mipmaps
+    std::vector<unsigned char> data(n_pixels * 4, 0);
+    nsvgRasterize(rast, image, 0, 0, scale, data.data(), m_width, m_height, m_width * 4);
+
+    // sends data to gpu
+    ::glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    ::glGenTextures(1, &m_id);
+    ::glBindTexture(GL_TEXTURE_2D, m_id);
+    ::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)m_width, (GLsizei)m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data());
+    if (use_mipmaps)
+    {
+        // we manually generate mipmaps because glGenerateMipmap() function is not reliable on all graphics cards
+        int lod_w = m_width;
+        int lod_h = m_height;
+        GLint level = 0;
+        while ((lod_w > 1) || (lod_h > 1))
+        {
+            ++level;
+
+            lod_w = std::max(lod_w / 2, 1);
+            lod_h = std::max(lod_h / 2, 1);
+            scale /= 2.0f;
+
+            nsvgRasterize(rast, image, 0, 0, scale, data.data(), lod_w, lod_h, lod_w * 4);
+            ::glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, (GLsizei)lod_w, (GLsizei)lod_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (const void*)data.data());
+        }
+
+        ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1 + level);
+        ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+    }
+    else
+    {
+        ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1);
+    }
+    ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+    ::glBindTexture(GL_TEXTURE_2D, 0);
+
+    m_source = filename;
+
+    nsvgDeleteRasterizer(rast);
+    nsvgDelete(image);
+
+    return true;
+}
+#endif // ENABLE_TEXTURES_FROM_SVG
+
 } // namespace GUI
 } // namespace Slic3r

src/slic3r/GUI/GLTexture.hpp

@@ -37,20 +37,28 @@ namespace GUI {
         GLTexture();
         virtual ~GLTexture();
 
-        bool load_from_file(const std::string& filename, bool generate_mipmaps);
+        bool load_from_file(const std::string& filename, bool use_mipmaps);
+#if ENABLE_TEXTURES_FROM_SVG
+        bool load_from_svg_file(const std::string& filename, bool use_mipmaps, unsigned int max_size_px);
+#endif // ENABLE_TEXTURES_FROM_SVG
         void reset();
 
-        unsigned int get_id() const;
-        int get_width() const;
-        int get_height() const;
+        unsigned int get_id() const { return m_id; }
+        int get_width() const { return m_width; }
+        int get_height() const { return m_height; }
 
-        const std::string& get_source() const;
+        const std::string& get_source() const { return m_source; }
 
         static void render_texture(unsigned int tex_id, float left, float right, float bottom, float top);
         static void render_sub_texture(unsigned int tex_id, float left, float right, float bottom, float top, const Quad_UVs& uvs);
 
     protected:
-        unsigned int _generate_mipmaps(wxImage& image);
+        unsigned int generate_mipmaps(wxImage& image);
+#if ENABLE_TEXTURES_FROM_SVG
+    private:
+        bool load_from_png(const std::string& filename, bool use_mipmaps);
+        bool load_from_svg(const std::string& filename, bool use_mipmaps, unsigned int max_size_px);
+#endif // ENABLE_TEXTURES_FROM_SVG
     };
 
 } // namespace GUI