Merge remote-tracking branch 'origin/et_seams_as_models'

resources/shaders/gouraud_light_instanced.fs

@@ -0,0 +1,12 @@
+#version 110
+
+uniform vec4 uniform_color;
+uniform float emission_factor;
+
+// x = tainted, y = specular;
+varying vec2 intensity;
+
+void main()
+{
+    gl_FragColor = vec4(vec3(intensity.y) + uniform_color.rgb * (intensity.x + emission_factor), uniform_color.a);
+}

resources/shaders/gouraud_light_instanced.vs

@@ -0,0 +1,46 @@
+#version 110
+
+#define INTENSITY_CORRECTION 0.6
+
+// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31)
+const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
+#define LIGHT_TOP_DIFFUSE    (0.8 * INTENSITY_CORRECTION)
+#define LIGHT_TOP_SPECULAR   (0.125 * INTENSITY_CORRECTION)
+#define LIGHT_TOP_SHININESS  20.0
+
+// normalized values for (1./1.43, 0.2/1.43, 1./1.43)
+const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
+#define LIGHT_FRONT_DIFFUSE  (0.3 * INTENSITY_CORRECTION)
+
+#define INTENSITY_AMBIENT    0.3
+
+// vertex attributes
+in vec3 v_position;
+in vec3 v_normal;
+// instance attributes
+in vec3 i_offset;
+in vec2 i_scales;
+
+// x = tainted, y = specular;
+varying vec2 intensity;
+
+void main()
+{
+    // First transform the normal into camera space and normalize the result.
+    vec3 eye_normal = normalize(gl_NormalMatrix * v_normal);
+    
+    // Compute the cos of the angle between the normal and lights direction. The light is directional so the direction is constant for every vertex.
+    // Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.
+    float NdotL = max(dot(eye_normal, LIGHT_TOP_DIR), 0.0);
+
+    intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE;
+    vec4 world_position = vec4(v_position * vec3(vec2(i_scales.x), i_scales.y) + i_offset, 1.0);
+    vec3 eye_position = (gl_ModelViewMatrix * world_position).xyz;
+    intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(eye_position), reflect(-LIGHT_TOP_DIR, eye_normal)), 0.0), LIGHT_TOP_SHININESS);
+
+    // Perform the same lighting calculation for the 2nd light source (no specular applied).
+    NdotL = max(dot(eye_normal, LIGHT_FRONT_DIR), 0.0);
+    intensity.x += NdotL * LIGHT_FRONT_DIFFUSE;
+
+    gl_Position = gl_ProjectionMatrix * vec4(eye_position, 1.0);
+}

src/libslic3r/Technologies.hpp

@@ -51,6 +51,8 @@
 #define ENABLE_RETRACT_ACCELERATION (1 && ENABLE_2_4_0_ALPHA0)
 // Enable the fix for exporting and importing to/from 3mf file of mirrored volumes
 #define ENABLE_FIX_MIRRORED_VOLUMES_3MF_IMPORT_EXPORT (1 && ENABLE_2_4_0_ALPHA0)
+// Enable rendering seams (and other options) in preview using models
+#define ENABLE_SEAMS_USING_MODELS (1 && ENABLE_2_4_0_ALPHA0)
 
 
 #endif // _prusaslicer_technologies_h_

src/slic3r/GUI/3DBed.cpp

@@ -119,7 +119,7 @@ void Bed3D::Axes::render() const
     glsafe(::glEnable(GL_DEPTH_TEST));
 
     shader->start_using();
-    shader->set_uniform("emission_factor", 0.0);
+    shader->set_uniform("emission_factor", 0.0f);
 
     // x axis
     const_cast<GLModel*>(&m_arrow)->set_color(-1, { 0.75f, 0.0f, 0.0f, 1.0f });
@@ -498,7 +498,7 @@ void Bed3D::render_model() const
         GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
         if (shader != nullptr) {
             shader->start_using();
-            shader->set_uniform("emission_factor", 0.0);
+            shader->set_uniform("emission_factor", 0.0f);
             glsafe(::glPushMatrix());
             glsafe(::glTranslated(m_model_offset.x(), m_model_offset.y(), m_model_offset.z()));
             model->render();

src/slic3r/GUI/GCodeViewer.hpp

@@ -22,17 +22,22 @@ namespace GUI {
 class GCodeViewer
 {
     using IBufferType = unsigned short;
-    using Color = std::array<float, 3>;
+    using Color = std::array<float, 4>;
     using VertexBuffer = std::vector<float>;
     using MultiVertexBuffer = std::vector<VertexBuffer>;
     using IndexBuffer = std::vector<IBufferType>;
     using MultiIndexBuffer = std::vector<IndexBuffer>;
+#if ENABLE_SEAMS_USING_MODELS
+    using InstanceBuffer = std::vector<float>;
+    using InstanceIdBuffer = std::vector<size_t>;
+#endif // ENABLE_SEAMS_USING_MODELS
 
     static const std::vector<Color> Extrusion_Role_Colors;
     static const std::vector<Color> Options_Colors;
     static const std::vector<Color> Travel_Colors;
-    static const Color              Wipe_Color;
     static const std::vector<Color> Range_Colors;
+    static const Color              Wipe_Color;
+    static const Color              Neutral_Color;
 
     enum class EOptionsColors : unsigned char
     {
@@ -80,7 +85,10 @@ class GCodeViewer
         size_t position_size_floats() const { return 3; }
         size_t position_size_bytes() const { return position_size_floats() * sizeof(float); }
 
-        size_t normal_offset_floats() const { return position_size_floats(); }
+        size_t normal_offset_floats() const {
+            assert(format == EFormat::PositionNormal1 || format == EFormat::PositionNormal3);
+            return position_size_floats();
+        }
         size_t normal_offset_bytes() const { return normal_offset_floats() * sizeof(float); }
 
         size_t normal_size_floats() const {
@@ -96,6 +104,47 @@ class GCodeViewer
         void reset();
     };
 
+#if ENABLE_SEAMS_USING_MODELS
+    // buffer containing instances data used to render a toolpaths using instanced models
+    // instance record format: 5 floats -> position.x|position.y|position.z|width|height
+    // which is sent to the shader as -> vec3 (offset) + vec2 (scales) in GLModel::render_instanced()
+    struct InstanceVBuffer
+    {
+        // ranges used to render only subparts of the intances
+        struct Ranges
+        {
+            struct Range
+            {
+                // offset in bytes of the 1st instance to render
+                unsigned int offset;
+                // count of instances to render
+                unsigned int count;
+                // vbo id
+                unsigned int vbo{ 0 };
+                // Color to apply to the instances
+                Color color;
+            };
+
+            std::vector<Range> ranges;
+
+            void reset();
+        };
+
+        // cpu-side buffer containing all instances data
+        InstanceBuffer buffer;
+        // indices of the moves for all instances
+        std::vector<size_t> s_ids;
+        Ranges render_ranges;
+
+        size_t data_size_bytes() const { return s_ids.size() * instance_size_bytes(); }
+
+        size_t instance_size_floats() const { return 5; }
+        size_t instance_size_bytes() const { return instance_size_floats() * sizeof(float); }
+
+        void reset();
+    };
+#endif // ENABLE_SEAMS_USING_MODELS
+
     // ibo buffer containing indices data (for lines/triangles) used to render a specific toolpath type
     struct IBuffer
     {
@@ -229,13 +278,34 @@ class GCodeViewer
         {
             Point,
             Line,
+#if ENABLE_SEAMS_USING_MODELS
+            Triangle,
+            Model
+#else
             Triangle
+#endif // ENABLE_SEAMS_USING_MODELS
         };
 
         ERenderPrimitiveType render_primitive_type;
+
+        // buffers for point, line and triangle primitive types
         VBuffer vertices;
         std::vector<IBuffer> indices;
 
+#if ENABLE_SEAMS_USING_MODELS
+        struct Model
+        {
+            GLModel model;
+            Color color;
+            InstanceVBuffer instances;
+
+            void reset();
+        };
+
+        // contain the buffer for model primitive types
+        Model model;
+#endif // ENABLE_SEAMS_USING_MODELS
+
         std::string shader;
         std::vector<Path> paths;
         // std::set seems to perform significantly better, at least on Windows.
@@ -283,9 +353,24 @@ class GCodeViewer
         }
         size_t max_indices_per_segment_size_bytes() const { return max_indices_per_segment() * sizeof(IBufferType); }
 
+#if ENABLE_SEAMS_USING_MODELS
+        bool has_data() const {
+            switch (render_primitive_type)
+            {
+            case ERenderPrimitiveType::Point:
+            case ERenderPrimitiveType::Line:
+            case ERenderPrimitiveType::Triangle: {
+                return !vertices.vbos.empty() && vertices.vbos.front() != 0 && !indices.empty() && indices.front().ibo != 0;
+            }
+            case ERenderPrimitiveType::Model: { return model.model.is_initialized() && !model.instances.buffer.empty(); }
+            default: { return false; }
+            }
+        }
+#else
         bool has_data() const {
             return !vertices.vbos.empty() && vertices.vbos.front() != 0 && !indices.empty() && indices.front().ibo != 0;
         }
+#endif // ENABLE_SEAMS_USING_MODELS
     };
 
     // helper to render shells
@@ -433,18 +518,30 @@ class GCodeViewer
         int64_t gl_multi_lines_calls_count{ 0 };
         int64_t gl_multi_triangles_calls_count{ 0 };
         int64_t gl_triangles_calls_count{ 0 };
+#if ENABLE_SEAMS_USING_MODELS
+        int64_t gl_instanced_models_calls_count{ 0 };
+#endif // ENABLE_SEAMS_USING_MODELS
         // memory
         int64_t results_size{ 0 };
         int64_t total_vertices_gpu_size{ 0 };
         int64_t total_indices_gpu_size{ 0 };
+#if ENABLE_SEAMS_USING_MODELS
+        int64_t total_instances_gpu_size{ 0 };
+#endif // ENABLE_SEAMS_USING_MODELS
         int64_t max_vbuffer_gpu_size{ 0 };
         int64_t max_ibuffer_gpu_size{ 0 };
         int64_t paths_size{ 0 };
         int64_t render_paths_size{ 0 };
+#if ENABLE_SEAMS_USING_MODELS
+        int64_t models_instances_size{ 0 };
+#endif // ENABLE_SEAMS_USING_MODELS
         // other
         int64_t travel_segments_count{ 0 };
         int64_t wipe_segments_count{ 0 };
         int64_t extrude_segments_count{ 0 };
+#if ENABLE_SEAMS_USING_MODELS
+        int64_t instances_count{ 0 };
+#endif // ENABLE_SEAMS_USING_MODELS
         int64_t vbuffers_count{ 0 };
         int64_t ibuffers_count{ 0 };
 
@@ -470,22 +567,34 @@ class GCodeViewer
             gl_multi_lines_calls_count = 0;
             gl_multi_triangles_calls_count = 0;
             gl_triangles_calls_count = 0;
+#if ENABLE_SEAMS_USING_MODELS
+            gl_instanced_models_calls_count = 0;
+#endif // ENABLE_SEAMS_USING_MODELS
         }
 
         void reset_sizes() {
             results_size = 0;
             total_vertices_gpu_size = 0;
             total_indices_gpu_size = 0;
+#if ENABLE_SEAMS_USING_MODELS
+            total_instances_gpu_size = 0;
+#endif // ENABLE_SEAMS_USING_MODELS
             max_vbuffer_gpu_size = 0;
             max_ibuffer_gpu_size = 0;
             paths_size = 0;
             render_paths_size = 0;
+#if ENABLE_SEAMS_USING_MODELS
+            models_instances_size = 0;
+#endif // ENABLE_SEAMS_USING_MODELS
         }
 
         void reset_others() {
             travel_segments_count = 0;
             wipe_segments_count = 0;
             extrude_segments_count =  0;
+#if ENABLE_SEAMS_USING_MODELS
+            instances_count = 0;
+#endif // ENABLE_SEAMS_USING_MODELS
             vbuffers_count = 0;
             ibuffers_count = 0;
         }
@@ -563,6 +672,9 @@ public:
         Endpoints endpoints;
         Endpoints current;
         Endpoints last_current;
+#if ENABLE_SEAMS_USING_MODELS
+        Endpoints global;
+#endif // ENABLE_SEAMS_USING_MODELS
         Vec3f current_position{ Vec3f::Zero() };
         Marker marker;
         GCodeWindow gcode_window;
@@ -632,7 +744,7 @@ public:
     void update_shells_color_by_extruder(const DynamicPrintConfig* config);
 
     void reset();
-    void render() const;
+    void render();
 
     bool has_data() const { return !m_roles.empty(); }
     bool can_export_toolpaths() const;
@@ -678,17 +790,18 @@ private:
     void load_toolpaths(const GCodeProcessor::Result& gcode_result);
     void load_shells(const Print& print, bool initialized);
     void refresh_render_paths(bool keep_sequential_current_first, bool keep_sequential_current_last) const;
-    void render_toolpaths() const;
+    void render_toolpaths();
-    void render_shells() const;
+    void render_shells();
-    void render_legend(float& legend_height) const;
+    void render_legend(float& legend_height);
 #if ENABLE_GCODE_VIEWER_STATISTICS
-    void render_statistics() const;
+    void render_statistics();
 #endif // ENABLE_GCODE_VIEWER_STATISTICS
     bool is_visible(ExtrusionRole role) const {
         return role < erCount && (m_extrusions.role_visibility_flags & (1 << role)) != 0;
     }
     bool is_visible(const Path& path) const { return is_visible(path.role); }
     void log_memory_used(const std::string& label, int64_t additional = 0) const;
+    Color option_color(EMoveType move_type) const;
 };
 
 } // namespace GUI

src/slic3r/GUI/GLCanvas3D.cpp

@@ -4148,7 +4148,7 @@ void GLCanvas3D::_render_thumbnail_internal(ThumbnailData& thumbnail_data, const
     glsafe(::glEnable(GL_DEPTH_TEST));
 
     shader->start_using();
-    shader->set_uniform("emission_factor", 0.0);
+    shader->set_uniform("emission_factor", 0.0f);
 
     for (GLVolume* vol : visible_volumes) {
         shader->set_uniform("uniform_color", (vol->printable && !vol->is_outside) ? orange : gray);
@@ -5170,7 +5170,7 @@ void GLCanvas3D::_render_objects()
     m_camera_clipping_plane = ClippingPlane::ClipsNothing();
 }
 
-void GLCanvas3D::_render_gcode() const
+void GLCanvas3D::_render_gcode()
 {
     m_gcode_viewer.render();
 }

src/slic3r/GUI/GLCanvas3D.hpp

@@ -904,7 +904,7 @@ private:
 #else
     void _render_objects();
 #endif // ENABLE_DELAYED_TRANSPARENT_VOLUMES_RENDERING
-    void _render_gcode() const;
+    void _render_gcode();
     void _render_selection() const;
     void _render_sequential_clearance();
 #if ENABLE_RENDER_SELECTION_CENTER

src/slic3r/GUI/GLModel.cpp

@@ -208,6 +208,85 @@ void GLModel::render() const
     }
 }
 
+#if ENABLE_SEAMS_USING_MODELS
+void GLModel::render_instanced(unsigned int instances_vbo, unsigned int instances_count) const
+{
+    if (instances_vbo == 0)
+        return;
+
+    GLShaderProgram* shader = wxGetApp().get_current_shader();
+    assert(shader == nullptr || boost::algorithm::iends_with(shader->get_name(), "_instanced"));
+
+    // vertex attributes
+    GLint position_id = (shader != nullptr) ? shader->get_attrib_location("v_position") : -1;
+    GLint normal_id = (shader != nullptr) ? shader->get_attrib_location("v_normal") : -1;
+    assert(position_id != -1 && normal_id != -1);
+
+    // instance attributes
+    GLint offset_id = (shader != nullptr) ? shader->get_attrib_location("i_offset") : -1;
+    GLint scales_id = (shader != nullptr) ? shader->get_attrib_location("i_scales") : -1;
+    assert(offset_id != -1 && scales_id != -1);
+
+    glsafe(::glBindBuffer(GL_ARRAY_BUFFER, instances_vbo));
+    if (offset_id != -1) {
+        glsafe(::glVertexAttribPointer(offset_id, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (GLvoid*)0));
+        glsafe(::glEnableVertexAttribArray(offset_id));
+        glsafe(::glVertexAttribDivisor(offset_id, 1));
+    }
+    if (scales_id != -1) {
+        glsafe(::glVertexAttribPointer(scales_id, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (GLvoid*)(3 * sizeof(float))));
+        glsafe(::glEnableVertexAttribArray(scales_id));
+        glsafe(::glVertexAttribDivisor(scales_id, 1));
+    }
+
+    for (const RenderData& data : m_render_data) {
+        if (data.vbo_id == 0 || data.ibo_id == 0)
+            continue;
+
+        GLenum mode;
+        switch (data.type)
+        {
+        default:
+        case PrimitiveType::Triangles: { mode = GL_TRIANGLES; break; }
+        case PrimitiveType::Lines:     { mode = GL_LINES; break; }
+        case PrimitiveType::LineStrip: { mode = GL_LINE_STRIP; break; }
+        case PrimitiveType::LineLoop:  { mode = GL_LINE_LOOP; break; }
+        }
+
+        if (shader != nullptr)
+            shader->set_uniform("uniform_color", data.color);
+        else
+            glsafe(::glColor4fv(data.color.data()));
+
+        glsafe(::glBindBuffer(GL_ARRAY_BUFFER, data.vbo_id));
+        if (position_id != -1) {
+            glsafe(::glVertexAttribPointer(position_id, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (GLvoid*)0));
+            glsafe(::glEnableVertexAttribArray(position_id));
+        }
+        if (normal_id != -1) {
+            glsafe(::glVertexAttribPointer(normal_id, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (GLvoid*)(3 * sizeof(float))));
+            glsafe(::glEnableVertexAttribArray(normal_id));
+        }
+
+        glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, data.ibo_id));
+        glsafe(::glDrawElementsInstanced(mode, static_cast<GLsizei>(data.indices_count), GL_UNSIGNED_INT, (const void*)0, instances_count));
+        glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
+
+        if (normal_id != -1)
+            glsafe(::glDisableVertexAttribArray(normal_id));
+        if (position_id != -1)
+            glsafe(::glDisableVertexAttribArray(position_id));
+    }
+
+    if (scales_id != -1)
+        glsafe(::glDisableVertexAttribArray(scales_id));
+    if (offset_id != -1)
+        glsafe(::glDisableVertexAttribArray(offset_id));
+
+    glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
+}
+#endif // ENABLE_SEAMS_USING_MODELS
+
 void GLModel::send_to_gpu(RenderData& data, const std::vector<float>& vertices, const std::vector<unsigned int>& indices)
 {
     assert(data.vbo_id == 0);
@@ -598,5 +677,53 @@ GLModel::InitializationData straight_arrow(float tip_width, float tip_height, fl
     return data;
 }
 
+GLModel::InitializationData diamond(int resolution)
+{
+    resolution = std::max(4, resolution);
+
+    GLModel::InitializationData data;
+    GLModel::InitializationData::Entity entity;
+    entity.type = GLModel::PrimitiveType::Triangles;
+
+    const float step = 2.0f * float(PI) / float(resolution);
+
+    // positions
+    for (int i = 0; i < resolution; ++i) {
+        float ii = float(i) * step;
+        entity.positions.emplace_back(0.5f * ::cos(ii), 0.5f * ::sin(ii), 0.0f);
+    }
+    entity.positions.emplace_back(0.0f, 0.0f, 0.5f);
+    entity.positions.emplace_back(0.0f, 0.0f, -0.5f);
+
+    // normals
+    for (const Vec3f& v : entity.positions) {
+        entity.normals.emplace_back(v.normalized());
+    }
+
+    // triangles
+    // top
+    for (int i = 0; i < resolution; ++i) {
+        entity.indices.push_back(i + 0);
+        entity.indices.push_back(i + 1);
+        entity.indices.push_back(resolution);
+    }
+    entity.indices.push_back(resolution - 1);
+    entity.indices.push_back(0);
+    entity.indices.push_back(resolution);
+
+    // bottom
+    for (int i = 0; i < resolution; ++i) {
+        entity.indices.push_back(i + 0);
+        entity.indices.push_back(resolution + 1);
+        entity.indices.push_back(i + 1);
+    }
+    entity.indices.push_back(resolution - 1);
+    entity.indices.push_back(resolution + 1);
+    entity.indices.push_back(0);
+
+    data.entities.emplace_back(entity);
+    return data;
+}
+
 } // namespace GUI
 } // namespace Slic3r

src/slic3r/GUI/GLModel.hpp

@@ -72,6 +72,9 @@ namespace GUI {
 
         void reset();
         void render() const;
+#if ENABLE_SEAMS_USING_MODELS
+        void render_instanced(unsigned int instances_vbo, unsigned int instances_count) const;
+#endif // ENABLE_SEAMS_USING_MODELS
 
         bool is_initialized() const { return !m_render_data.empty(); }
 
@@ -100,6 +103,11 @@ namespace GUI {
     // used to render sidebar hints for position and scale
     GLModel::InitializationData straight_arrow(float tip_width, float tip_height, float stem_width, float stem_height, float thickness);
 
+    // create a diamond with the given resolution
+    // the origin of the diamond is in its center
+    // the diamond is contained into a box with size [1, 1, 1]
+    GLModel::InitializationData diamond(int resolution);
+
 } // namespace GUI
 } // namespace Slic3r
 

src/slic3r/GUI/GLShadersManager.cpp

@@ -38,9 +38,17 @@ std::pair<bool, std::string> GLShadersManager::init()
     // used to render printbed
     valid &= append_shader("printbed", { "printbed.vs", "printbed.fs" });
     // used to render options in gcode preview
-    valid &= append_shader("options_110", { "options_110.vs", "options_110.fs" });
+#if ENABLE_SEAMS_USING_MODELS
-    if (GUI::wxGetApp().is_glsl_version_greater_or_equal_to(1, 20))
+    if (GUI::wxGetApp().is_gl_version_greater_or_equal_to(3, 1))
-        valid &= append_shader("options_120", { "options_120.vs", "options_120.fs" });
+        valid &= append_shader("gouraud_light_instanced", { "gouraud_light_instanced.vs", "gouraud_light_instanced.fs" });
+    else {
+#endif // ENABLE_SEAMS_USING_MODELS
+        valid &= append_shader("options_110", { "options_110.vs", "options_110.fs" });
+        if (GUI::wxGetApp().is_glsl_version_greater_or_equal_to(1, 20))
+            valid &= append_shader("options_120", { "options_120.vs", "options_120.fs" });
+#if ENABLE_SEAMS_USING_MODELS
+    }
+#endif // ENABLE_SEAMS_USING_MODELS
     // used to render extrusion and travel paths as lines in gcode preview
     valid &= append_shader("toolpaths_lines", { "toolpaths_lines.vs", "toolpaths_lines.fs" });
     // used to render objects in 3d editor

src/slic3r/GUI/Gizmos/GLGizmoBase.cpp

@@ -191,7 +191,7 @@ void GLGizmoBase::render_grabbers(float size) const
     if (shader == nullptr)
         return;
     shader->start_using();
-    shader->set_uniform("emission_factor", 0.1);
+    shader->set_uniform("emission_factor", 0.1f);
     for (int i = 0; i < (int)m_grabbers.size(); ++i) {
         if (m_grabbers[i].enabled)
             m_grabbers[i].render(m_hover_id == i, size);

src/slic3r/GUI/Gizmos/GLGizmoCut.cpp

@@ -136,7 +136,7 @@ void GLGizmoCut::on_render()
     if (shader == nullptr)
         return;
     shader->start_using();
-    shader->set_uniform("emission_factor", 0.1);
+    shader->set_uniform("emission_factor", 0.1f);
 
     m_grabbers[0].color = GrabberColor;
     m_grabbers[0].render(m_hover_id == 0, (float)((box.size().x() + box.size().y() + box.size().z()) / 3.0));

src/slic3r/GUI/Gizmos/GLGizmoMove.cpp

@@ -141,7 +141,7 @@ void GLGizmoMove3D::on_render()
         GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
         if (shader != nullptr) {
             shader->start_using();
-            shader->set_uniform("emission_factor", 0.1);
+            shader->set_uniform("emission_factor", 0.1f);
             // draw grabber
             float mean_size = (float)((box.size().x() + box.size().y() + box.size().z()) / 3.0);
             m_grabbers[m_hover_id].render(true, mean_size);
@@ -208,7 +208,7 @@ void GLGizmoMove3D::render_grabber_extension(Axis axis, const BoundingBoxf3& box
     const_cast<GLModel*>(&m_vbo_cone)->set_color(-1, color);
     if (!picking) {
         shader->start_using();
-        shader->set_uniform("emission_factor", 0.1);
+        shader->set_uniform("emission_factor", 0.1f);
     }
 
     glsafe(::glPushMatrix());

src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp

@@ -339,7 +339,7 @@ void GLGizmoRotate::render_grabber_extension(const BoundingBoxf3& box, bool pick
     const_cast<GLModel*>(&m_cone)->set_color(-1, color);
     if (!picking) {
         shader->start_using();
-        shader->set_uniform("emission_factor", 0.1);
+        shader->set_uniform("emission_factor", 0.1f);
     }
 
     glsafe(::glPushMatrix());

src/slic3r/GUI/Gizmos/GLGizmoScale.cpp

@@ -236,7 +236,7 @@ void GLGizmoScale3D::on_render()
         GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
         if (shader != nullptr) {
             shader->start_using();
-            shader->set_uniform("emission_factor", 0.1);
+            shader->set_uniform("emission_factor", 0.1f);
             // draw grabbers
             m_grabbers[0].render(true, grabber_mean_size);
             m_grabbers[1].render(true, grabber_mean_size);
@@ -251,7 +251,7 @@ void GLGizmoScale3D::on_render()
         GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
         if (shader != nullptr) {
             shader->start_using();
-            shader->set_uniform("emission_factor", 0.1);
+            shader->set_uniform("emission_factor", 0.1f);
             // draw grabbers
             m_grabbers[2].render(true, grabber_mean_size);
             m_grabbers[3].render(true, grabber_mean_size);
@@ -266,7 +266,7 @@ void GLGizmoScale3D::on_render()
         GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
         if (shader != nullptr) {
             shader->start_using();
-            shader->set_uniform("emission_factor", 0.1);
+            shader->set_uniform("emission_factor", 0.1f);
             // draw grabbers
             m_grabbers[4].render(true, grabber_mean_size);
             m_grabbers[5].render(true, grabber_mean_size);
@@ -284,7 +284,7 @@ void GLGizmoScale3D::on_render()
         GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light");
         if (shader != nullptr) {
             shader->start_using();
-            shader->set_uniform("emission_factor", 0.1);
+            shader->set_uniform("emission_factor", 0.1f);
             // draw grabbers
             for (int i = 6; i < 10; ++i) {
                 m_grabbers[i].render(true, grabber_mean_size);

src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp

@@ -169,7 +169,7 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
         const_cast<GLModel*>(&m_cone)->set_color(-1, render_color);
         const_cast<GLModel*>(&m_sphere)->set_color(-1, render_color);
         if (shader && !picking)
-            shader->set_uniform("emission_factor", 0.5);
+            shader->set_uniform("emission_factor", 0.5f);
 
         // Inverse matrix of the instance scaling is applied so that the mark does not scale with the object.
         glsafe(::glPushMatrix());
@@ -224,7 +224,7 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
         render_color[3] = 0.7f;
         const_cast<GLModel*>(&m_cylinder)->set_color(-1, render_color);
         if (shader)
-            shader->set_uniform("emission_factor", 0.5);
+            shader->set_uniform("emission_factor", 0.5f);
         for (const sla::DrainHole& drain_hole : m_c->selection_info()->model_object()->sla_drain_holes) {
             if (is_mesh_point_clipped(drain_hole.pos.cast<double>()))
                 continue;

src/slic3r/GUI/Selection.cpp

@@ -1874,7 +1874,7 @@ void Selection::render_sidebar_scale_hints(const std::string& sidebar_field) con
         const_cast<GLModel*>(&m_arrow)->set_color(-1, uniform_scale ? UNIFORM_SCALE_COLOR : get_color(axis));
         GLShaderProgram* shader = wxGetApp().get_current_shader();
         if (shader != nullptr)
-            shader->set_uniform("emission_factor", 0.0);
+            shader->set_uniform("emission_factor", 0.0f);
 
         glsafe(::glTranslated(0.0, 5.0, 0.0));
         m_arrow.render();