Tech ENABLE_LEGACY_OPENGL_REMOVAL - Fixed calculation of normal matrices sent to shaders

(cherry picked from commit prusa3d/PrusaSlicer@c468dcbed7)

resources/shaders/110/gouraud.vs

@@ -27,7 +27,7 @@ struct SlopeDetection
 
 uniform mat4 view_model_matrix;
 uniform mat4 projection_matrix;
-uniform mat3 normal_matrix;
+uniform mat3 view_normal_matrix;
 uniform mat4 volume_world_matrix;
 uniform SlopeDetection slope;
 
@@ -51,7 +51,7 @@ varying vec3 eye_normal;
 void main()
 {
 	// First transform the normal into camera space and normalize the result.
-    eye_normal = normalize(normal_matrix * v_normal);
+    eye_normal = normalize(view_normal_matrix * 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.

resources/shaders/110/gouraud_light.vs

@@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
 
 uniform mat4 view_model_matrix;
 uniform mat4 projection_matrix;
-uniform mat3 normal_matrix;
+uniform mat3 view_normal_matrix;
 
 attribute vec3 v_position;
 attribute vec3 v_normal;
@@ -27,7 +27,7 @@ varying vec2 intensity;
 void main()
 {
     // First transform the normal into camera space and normalize the result.
-    vec3 normal = normalize(normal_matrix * v_normal);
+    vec3 normal = normalize(view_normal_matrix * 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.

resources/shaders/110/gouraud_light_instanced.vs

@@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
 
 uniform mat4 view_model_matrix;
 uniform mat4 projection_matrix;
-uniform mat3 normal_matrix;
+uniform mat3 view_normal_matrix;
 
 // vertex attributes
 attribute vec3 v_position;
@@ -31,7 +31,7 @@ varying vec2 intensity;
 void main()
 {
     // First transform the normal into camera space and normalize the result.
-    vec3 eye_normal = normalize(normal_matrix * v_normal);
+    vec3 eye_normal = normalize(view_normal_matrix * 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.

resources/shaders/110/mm_gouraud.fs

@@ -26,7 +26,7 @@ uniform vec4 uniform_color;
 uniform bool volume_mirrored;
 
 uniform mat4 view_model_matrix;
-uniform mat3 normal_matrix;
+uniform mat3 view_normal_matrix;
 
 varying vec3 clipping_planes_dots;
 varying vec4 model_pos;
@@ -70,7 +70,7 @@ void main()
         }
     }
     // First transform the normal into camera space and normalize the result.
-    vec3 eye_normal = normalize(normal_matrix * triangle_normal);
+    vec3 eye_normal = normalize(view_normal_matrix * triangle_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.

resources/shaders/110/thumbnail.vs

@@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
 
 uniform mat4 view_model_matrix;
 uniform mat4 projection_matrix;
-uniform mat3 normal_matrix;
+uniform mat3 view_normal_matrix;
 uniform mat4 volume_world_matrix;
 
 attribute vec3 v_position;
@@ -29,7 +29,7 @@ varying vec4 world_pos;
 void main()
 {
     // First transform the normal into camera space and normalize the result.
-    vec3 normal = normalize(normal_matrix * v_normal);
+    vec3 normal = normalize(view_normal_matrix * 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.

resources/shaders/110/variable_layer_height.vs

@@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
 
 uniform mat4 view_model_matrix;
 uniform mat4 projection_matrix;
-uniform mat3 normal_matrix;
+uniform mat3 view_normal_matrix;
 uniform mat4 volume_world_matrix;
 uniform float object_max_z;
 
@@ -38,7 +38,7 @@ void main()
 	// =====================================================
 
     // First transform the normal into camera space and normalize the result.
-    vec3 normal = (object_max_z > 0.0) ? vec3(0.0, 0.0, 1.0) : normalize(normal_matrix * v_normal);
+    vec3 normal = (object_max_z > 0.0) ? vec3(0.0, 0.0, 1.0) : normalize(view_normal_matrix * 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.

resources/shaders/140/gouraud.vs

@@ -27,7 +27,7 @@ struct SlopeDetection
 
 uniform mat4 view_model_matrix;
 uniform mat4 projection_matrix;
-uniform mat3 normal_matrix;
+uniform mat3 view_normal_matrix;
 uniform mat4 volume_world_matrix;
 uniform SlopeDetection slope;
 
@@ -51,7 +51,7 @@ out vec3 eye_normal;
 void main()
 {
 	// First transform the normal into camera space and normalize the result.
-    eye_normal = normalize(normal_matrix * v_normal);
+    eye_normal = normalize(view_normal_matrix * 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.

resources/shaders/140/gouraud_light.vs

@@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
 
 uniform mat4 view_model_matrix;
 uniform mat4 projection_matrix;
-uniform mat3 normal_matrix;
+uniform mat3 view_normal_matrix;
 
 in vec3 v_position;
 in vec3 v_normal;
@@ -27,7 +27,7 @@ out vec2 intensity;
 void main()
 {
     // First transform the normal into camera space and normalize the result.
-    vec3 normal = normalize(normal_matrix * v_normal);
+    vec3 normal = normalize(view_normal_matrix * 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.

resources/shaders/140/gouraud_light_instanced.vs

@@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
 
 uniform mat4 view_model_matrix;
 uniform mat4 projection_matrix;
-uniform mat3 normal_matrix;
+uniform mat3 view_normal_matrix;
 
 // vertex attributes
 in vec3 v_position;
@@ -31,7 +31,7 @@ out vec2 intensity;
 void main()
 {
     // First transform the normal into camera space and normalize the result.
-    vec3 eye_normal = normalize(normal_matrix * v_normal);
+    vec3 eye_normal = normalize(view_normal_matrix * 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.

resources/shaders/140/mm_gouraud.fs

@@ -26,7 +26,7 @@ uniform vec4 uniform_color;
 uniform bool volume_mirrored;
 
 uniform mat4 view_model_matrix;
-uniform mat3 normal_matrix;
+uniform mat3 view_normal_matrix;
 
 in vec3 clipping_planes_dots;
 in vec4 model_pos;
@@ -70,7 +70,7 @@ void main()
         }
     }
     // First transform the normal into camera space and normalize the result.
-    vec3 eye_normal = normalize(normal_matrix * triangle_normal);
+    vec3 eye_normal = normalize(view_normal_matrix * triangle_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.

resources/shaders/140/thumbnail.vs

@@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
 
 uniform mat4 view_model_matrix;
 uniform mat4 projection_matrix;
-uniform mat3 normal_matrix;
+uniform mat3 view_normal_matrix;
 uniform mat4 volume_world_matrix;
 
 in vec3 v_position;
@@ -29,7 +29,7 @@ out vec4 world_pos;
 void main()
 {
     // First transform the normal into camera space and normalize the result.
-    vec3 normal = normalize(normal_matrix * v_normal);
+    vec3 normal = normalize(view_normal_matrix * 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.

resources/shaders/140/variable_layer_height.vs

@@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
 
 uniform mat4 view_model_matrix;
 uniform mat4 projection_matrix;
-uniform mat3 normal_matrix;
+uniform mat3 view_normal_matrix;
 uniform mat4 volume_world_matrix;
 uniform float object_max_z;
 
@@ -38,7 +38,7 @@ void main()
 	// =====================================================
 
     // First transform the normal into camera space and normalize the result.
-    vec3 normal = (object_max_z > 0.0) ? vec3(0.0, 0.0, 1.0) : normalize(normal_matrix * v_normal);
+    vec3 normal = (object_max_z > 0.0) ? vec3(0.0, 0.0, 1.0) : normalize(view_normal_matrix * 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.

src/slic3r/GUI/3DBed.cpp

@@ -208,10 +208,11 @@ void Bed3D::Axes::render()
 {
     auto render_axis = [this](GLShaderProgram* shader, const Transform3d& transform) {
         const Camera& camera = wxGetApp().plater()->get_camera();
-        const Transform3d matrix = camera.get_view_matrix() * transform;
-        shader->set_uniform("view_model_matrix", matrix);
+        const Transform3d& view_matrix = camera.get_view_matrix();
+        shader->set_uniform("view_model_matrix", view_matrix * transform);
         shader->set_uniform("projection_matrix", camera.get_projection_matrix());
-        shader->set_uniform("normal_matrix",     (Matrix3d)matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * transform.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader->set_uniform("view_normal_matrix", view_normal_matrix);
         m_arrow.render();
     };
 
@@ -675,10 +676,11 @@ void Bed3D::render_model(const Transform3d& view_matrix, const Transform3d& proj
         if (shader != nullptr) {
             shader->start_using();
             shader->set_uniform("emission_factor", 0.0f);
-            const Transform3d matrix = view_matrix * Geometry::assemble_transform(m_model_offset);
-            shader->set_uniform("view_model_matrix", matrix);
+            const Transform3d model_matrix = Geometry::assemble_transform(m_model_offset);
+            shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
             shader->set_uniform("projection_matrix", projection_matrix);
-            shader->set_uniform("normal_matrix", (Matrix3d)matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+            const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+            shader->set_uniform("view_normal_matrix", view_normal_matrix);
             m_model.render();
             shader->stop_using();
         }

src/slic3r/GUI/3DScene.cpp

@@ -912,13 +912,14 @@ void GLVolumeCollection::render(GLVolumeCollection::ERenderType type, bool disab
         glcheck();
 
         volume.first->model.set_color(volume.first->render_color);
-        const Transform3d matrix = view_matrix * volume.first->world_matrix();
-        shader->set_uniform("view_model_matrix", matrix);
+        const Transform3d model_matrix = volume.first->world_matrix();
+        shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
         shader->set_uniform("projection_matrix", projection_matrix);
-        shader->set_uniform("normal_matrix", (Matrix3d)matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader->set_uniform("view_normal_matrix", view_normal_matrix);
 		//BBS: add outline related logic
         if (with_outline && volume.first->selected)
-            volume.first->render_with_outline(matrix);
+            volume.first->render_with_outline(view_matrix * model_matrix);
         else
             volume.first->render();
 

src/slic3r/GUI/GCodeViewer.cpp

@@ -318,10 +318,12 @@ void GCodeViewer::SequentialView::Marker::render(int canvas_width, int canvas_he
     shader->set_uniform("emission_factor", 0.0f);
 
     const Camera& camera = wxGetApp().plater()->get_camera();
-    const Transform3d matrix = camera.get_view_matrix() * m_world_transform.cast<double>();
-    shader->set_uniform("view_model_matrix", matrix);
+    const Transform3d& view_matrix = camera.get_view_matrix();
+    const Transform3d model_matrix = m_world_transform.cast<double>();
+    shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
     shader->set_uniform("projection_matrix", camera.get_projection_matrix());
-    shader->set_uniform("normal_matrix", (Matrix3d)matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+    const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+    shader->set_uniform("view_normal_matrix", view_normal_matrix);
 
     m_model.render();
 
@@ -3887,10 +3889,9 @@ void GCodeViewer::render_toolpaths()
 
         shader->start_using();
 
-        const Transform3d& view_matrix = camera.get_view_matrix();
-        shader->set_uniform("view_model_matrix", view_matrix);
+        shader->set_uniform("view_model_matrix", camera.get_view_matrix());
         shader->set_uniform("projection_matrix", camera.get_projection_matrix());
-        shader->set_uniform("normal_matrix", (Matrix3d)view_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        shader->set_uniform("view_normal_matrix", (Matrix3d)Matrix3d::Identity());
 
         if (buffer.render_primitive_type == TBuffer::ERenderPrimitiveType::InstancedModel) {
             shader->set_uniform("emission_factor", 0.25f);
@@ -3974,10 +3975,9 @@ void GCodeViewer::render_toolpaths()
 
         shader->start_using();
 
-        const Transform3d& view_matrix = camera.get_view_matrix();
-        shader->set_uniform("view_model_matrix", view_matrix);
+        shader->set_uniform("view_model_matrix", camera.get_view_matrix());
         shader->set_uniform("projection_matrix", camera.get_projection_matrix());
-        shader->set_uniform("normal_matrix", (Matrix3d)view_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        shader->set_uniform("view_normal_matrix", (Matrix3d)Matrix3d::Identity());
 
         const int position_id = shader->get_attrib_location("v_position");
         const int normal_id   = shader->get_attrib_location("v_normal");

src/slic3r/GUI/GLCanvas3D.cpp

@@ -410,7 +410,7 @@ void GLCanvas3D::LayersEditing::render_active_object_annotations(const GLCanvas3
     shader->set_uniform("object_max_z", m_object_max_z);
     shader->set_uniform("view_model_matrix", Transform3d::Identity());
     shader->set_uniform("projection_matrix", Transform3d::Identity());
-    shader->set_uniform("normal_matrix", (Matrix3d)Eigen::Matrix3d::Identity());
+    shader->set_uniform("view_normal_matrix", (Matrix3d)Matrix3d::Identity());
 
     glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
     glsafe(::glBindTexture(GL_TEXTURE_2D, m_z_texture_id));
@@ -569,9 +569,11 @@ void GLCanvas3D::LayersEditing::render_volumes(const GLCanvas3D& canvas, const G
 
         shader->set_uniform("volume_world_matrix", glvolume->world_matrix());
         shader->set_uniform("object_max_z", 0.0f);
-        const Transform3d view_model_matrix = camera.get_view_matrix() * glvolume->world_matrix();
-        shader->set_uniform("view_model_matrix", view_model_matrix);
-        shader->set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        const Transform3d& view_matrix = camera.get_view_matrix();
+        const Transform3d model_matrix = glvolume->world_matrix();
+        shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
+        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader->set_uniform("view_normal_matrix", view_normal_matrix);
 
         glvolume->render();
     }
@@ -5597,10 +5599,11 @@ void GLCanvas3D::render_thumbnail_internal(ThumbnailData& thumbnail_data, const
 
             const bool is_active = vol->is_active;
             vol->is_active = true;
-            const Transform3d matrix = view_matrix * vol->world_matrix();
-            shader->set_uniform("view_model_matrix", matrix);
+            const Transform3d model_matrix = vol->world_matrix();
+            shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
             shader->set_uniform("projection_matrix", projection_matrix);
-            shader->set_uniform("normal_matrix", (Matrix3d) matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+            const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+            shader->set_uniform("view_normal_matrix", view_normal_matrix); 
             vol->simple_render(shader, model_objects, extruder_colors);
             vol->is_active = is_active;
         }
@@ -5634,10 +5637,11 @@ void GLCanvas3D::render_thumbnail_internal(ThumbnailData& thumbnail_data, const
             // the volume may have been deactivated by an active gizmo
             const bool is_active = vol->is_active;
             vol->is_active = true;
-            const Transform3d matrix = view_matrix * vol->world_matrix();
-            shader->set_uniform("view_model_matrix", matrix);
+            const Transform3d model_matrix = vol->world_matrix();
+            shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
             shader->set_uniform("projection_matrix", projection_matrix);
-            shader->set_uniform("normal_matrix", (Matrix3d) matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+            const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+            shader->set_uniform("view_normal_matrix", view_normal_matrix); 
             vol->simple_render(shader,  model_objects, extruder_colors);
             vol->is_active = is_active;
         }

src/slic3r/GUI/Gizmos/GLGizmoAdvancedCut.cpp

@@ -527,7 +527,6 @@ void GLGizmoAdvancedCut::on_render_for_picking()
         Vec3d pos = connector.pos + instance_offset + sla_shift * Vec3d::UnitZ();
         float height = connector.height;
 
-        const Camera &camera = wxGetApp().plater()->get_camera();
         if (connector.attribs.type == CutConnectorType::Dowel && connector.attribs.style == CutConnectorStyle::Prizm) {
             pos -= height * m_cut_plane_normal;
             height *= 2;
@@ -540,11 +539,10 @@ void GLGizmoAdvancedCut::on_render_for_picking()
         Transform3d scale_tf = Transform3d::Identity();
         scale_tf.scale(Vec3f(connector.radius, connector.radius, height).cast<double>());
 
-        const Transform3d view_model_matrix = translate_tf * m_rotate_matrix * scale_tf;
-
+        const Transform3d model_matrix = translate_tf * m_rotate_matrix * scale_tf;
 
         ColorRGBA color = picking_color_component(i+1);
-        render_connector_model(m_shapes[connectors[i].attribs], color, view_model_matrix, true);
+        render_connector_model(m_shapes[connectors[i].attribs], color, model_matrix, true);
     }
 }
 
@@ -961,14 +959,14 @@ void GLGizmoAdvancedCut::render_cut_plane_and_grabbers()
 
         cube.set_color(render_color);
 
-        const Camera& camera = wxGetApp().plater()->get_camera();
-        const Transform3d view_model_matrix = camera.get_view_matrix() * Geometry::assemble_transform(m_move_grabber.center) *
-                                              m_rotate_matrix *
+        const Transform3d trafo_matrix = Geometry::assemble_transform(m_move_grabber.center) * m_rotate_matrix *
                                          Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), fullsize * Vec3d::Ones());
-        const Transform3d& projection_matrix = camera.get_projection_matrix();
-        shader->set_uniform("view_model_matrix", view_model_matrix);
-        shader->set_uniform("projection_matrix", projection_matrix);
-        shader->set_uniform("normal_matrix", (Matrix3d) view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        const Camera& camera = wxGetApp().plater()->get_camera();
+        const Transform3d& view_matrix = camera.get_view_matrix();
+        shader->set_uniform("view_model_matrix", view_matrix * trafo_matrix);
+        shader->set_uniform("projection_matrix", camera.get_projection_matrix());
+        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * trafo_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader->set_uniform("view_normal_matrix", view_normal_matrix);
         cube.render();
         shader->stop_using();
     }
@@ -1036,9 +1034,9 @@ void GLGizmoAdvancedCut::render_connectors()
         Transform3d scale_tf = Transform3d::Identity();
         scale_tf.scale(Vec3f(connector.radius, connector.radius, height).cast<double>());
 
-        const Transform3d view_model_matrix = translate_tf * m_rotate_matrix * scale_tf;
+        const Transform3d model_matrix = translate_tf * m_rotate_matrix * scale_tf;
 
-        render_connector_model(m_shapes[connector.attribs], render_color, view_model_matrix);
+        render_connector_model(m_shapes[connector.attribs], render_color, model_matrix);
     }
 }
 
@@ -1091,7 +1089,7 @@ void GLGizmoAdvancedCut::render_cut_line()
     }
 }
 
-void GLGizmoAdvancedCut::render_connector_model(GLModel &model, const ColorRGBA &color, Transform3d view_model_matrix, bool for_picking)
+void GLGizmoAdvancedCut::render_connector_model(GLModel &model, const ColorRGBA &color, Transform3d model_matrix, bool for_picking)
 {
     GLShaderProgram *shader = nullptr;
     if (for_picking)
@@ -1102,11 +1100,11 @@ void GLGizmoAdvancedCut::render_connector_model(GLModel &model, const ColorRGBA
         shader->start_using();
 
         const Camera& camera = wxGetApp().plater()->get_camera();
-        view_model_matrix = camera.get_view_matrix() * view_model_matrix;
-        const Transform3d &projection_matrix = camera.get_projection_matrix();
-        shader->set_uniform("view_model_matrix", view_model_matrix);
-        shader->set_uniform("projection_matrix", projection_matrix);
-        shader->set_uniform("normal_matrix", (Matrix3d) view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        const Transform3d& view_matrix = camera.get_view_matrix();
+        shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
+        shader->set_uniform("projection_matrix", camera.get_projection_matrix());
+        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader->set_uniform("view_normal_matrix", view_normal_matrix);
 
         model.set_color(color);
         model.render();

src/slic3r/GUI/Gizmos/GLGizmoAdvancedCut.hpp

@@ -204,7 +204,7 @@ private:
     void render_connectors();
     void render_clipper_cut();
     void render_cut_line();
-    void render_connector_model(GLModel &model, const ColorRGBA& color, Transform3d view_model_matrix, bool for_picking = false);
+    void render_connector_model(GLModel &model, const ColorRGBA& color, Transform3d model_matrix, bool for_picking = false);
 
     void clear_selection();
     void init_connector_shapes();

src/slic3r/GUI/Gizmos/GLGizmoBase.cpp

@@ -121,12 +121,14 @@ void GLGizmoBase::Grabber::render(float size, const ColorRGBA& render_color, boo
     m_cube.set_color(render_color);
 
     const Camera& camera = wxGetApp().plater()->get_camera();
-    const Transform3d view_model_matrix = camera.get_view_matrix() * matrix * Geometry::assemble_transform(center, angles, fullsize * Vec3d::Ones());
-    const Transform3d& projection_matrix = camera.get_projection_matrix();
+    const Transform3d& view_matrix = camera.get_view_matrix();
+    const Transform3d model_matrix = matrix * Geometry::assemble_transform(center, angles, fullsize * Vec3d::Ones());
+    const Transform3d view_model_matrix = view_matrix * model_matrix;
  
     shader->set_uniform("view_model_matrix", view_model_matrix);
-    shader->set_uniform("projection_matrix", projection_matrix);
-    shader->set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+    shader->set_uniform("projection_matrix", camera.get_projection_matrix());
+    const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+    shader->set_uniform("view_normal_matrix", view_normal_matrix);
     m_cube.render();
 }
 

src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.cpp

@@ -178,10 +178,11 @@ void GLGizmoFdmSupports::render_triangles(const Selection& selection) const
             glsafe(::glFrontFace(GL_CW));
 
         const Camera& camera = wxGetApp().plater()->get_camera();
-        const Transform3d matrix = camera.get_view_matrix() * trafo_matrix;
-        shader->set_uniform("view_model_matrix", matrix);
+        const Transform3d& view_matrix = camera.get_view_matrix();
+        shader->set_uniform("view_model_matrix", view_matrix * trafo_matrix);
         shader->set_uniform("projection_matrix", camera.get_projection_matrix());
-        shader->set_uniform("normal_matrix", (Matrix3d)matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * trafo_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader->set_uniform("view_normal_matrix", view_normal_matrix);
 
         float normal_z = -::cos(Geometry::deg2rad(m_highlight_by_angle_threshold_deg));
         Matrix3f normal_matrix = static_cast<Matrix3f>(trafo_matrix.matrix().block(0, 0, 3, 3).inverse().transpose().cast<float>());

src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp

@@ -158,11 +158,11 @@ void GLGizmoHollow::render_points(const Selection& selection, bool picking)
         Eigen::Quaterniond q;
         q.setFromTwoVectors(Vec3d::UnitZ(), instance_scaling_matrix_inverse * (-drain_hole.normal).cast<double>());
         const Eigen::AngleAxisd aa(q);
-        const Transform3d view_model_matrix = view_matrix * instance_matrix * hole_matrix * Transform3d(aa.toRotationMatrix()) *
+        const Transform3d model_matrix = instance_matrix * hole_matrix * Transform3d(aa.toRotationMatrix()) *
             Geometry::assemble_transform(-drain_hole.height * Vec3d::UnitZ(), Vec3d::Zero(), Vec3d(drain_hole.radius, drain_hole.radius, drain_hole.height + sla::HoleStickOutLength));
-
-        shader->set_uniform("view_model_matrix", view_model_matrix);
-        shader->set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
+        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader->set_uniform("view_normal_matrix", view_normal_matrix);
         m_cylinder.render();
 
         if (vol->is_left_handed())

src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.cpp

@@ -226,10 +226,11 @@ void GLGizmoMmuSegmentation::render_triangles(const Selection &selection) const
             glsafe(::glFrontFace(GL_CW));
 
         const Camera& camera = wxGetApp().plater()->get_camera();
-        const Transform3d matrix = camera.get_view_matrix() * trafo_matrix;
-        shader->set_uniform("view_model_matrix", matrix);
+        const Transform3d& view_matrix = camera.get_view_matrix();
+        shader->set_uniform("view_model_matrix", view_matrix * trafo_matrix);
         shader->set_uniform("projection_matrix", camera.get_projection_matrix());
-        shader->set_uniform("normal_matrix", (Matrix3d)matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * trafo_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader->set_uniform("view_normal_matrix", view_normal_matrix);
 
         shader->set_uniform("volume_world_matrix", trafo_matrix);
         shader->set_uniform("volume_mirrored", is_left_handed);

src/slic3r/GUI/Gizmos/GLGizmoMove.cpp

@@ -265,16 +265,18 @@ void GLGizmoMove3D::render_grabber_extension(Axis axis, const BoundingBoxf3& box
     shader->set_uniform("emission_factor", 0.1f);
 
     const Camera& camera = wxGetApp().plater()->get_camera();
-    Transform3d view_model_matrix = camera.get_view_matrix() * Geometry::assemble_transform(m_grabbers[axis].center);
+    const Transform3d& view_matrix = camera.get_view_matrix();
+    Transform3d model_matrix = Geometry::assemble_transform(m_grabbers[axis].center);
     if (axis == X)
-        view_model_matrix = view_model_matrix * Geometry::assemble_transform(Vec3d::Zero(), 0.5 * PI * Vec3d::UnitY());
+        model_matrix = model_matrix * Geometry::assemble_transform(Vec3d::Zero(), 0.5 * PI * Vec3d::UnitY());
     else if (axis == Y)
-        view_model_matrix = view_model_matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitX());
-    view_model_matrix = view_model_matrix * Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), Vec3d(0.75 * size, 0.75 * size, 2.0 * size));
+        model_matrix = model_matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitX());
+    model_matrix = model_matrix * Geometry::assemble_transform(2.0 * size * Vec3d::UnitZ(), Vec3d::Zero(), Vec3d(0.75 * size, 0.75 * size, 3.0 * size));
 
-    shader->set_uniform("view_model_matrix", view_model_matrix);
+    shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
     shader->set_uniform("projection_matrix", camera.get_projection_matrix());
-    shader->set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+    const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+    shader->set_uniform("view_normal_matrix", view_normal_matrix);
     m_cone.render();
 
     shader->stop_using();

src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp

@@ -107,10 +107,11 @@ void GLGizmoPainterBase::render_triangles(const Selection& selection) const
             glsafe(::glFrontFace(GL_CW));
 
         const Camera& camera = wxGetApp().plater()->get_camera();
-        const Transform3d matrix = camera.get_view_matrix() * trafo_matrix;
-        shader->set_uniform("view_model_matrix", matrix);
+        const Transform3d& view_matrix = camera.get_view_matrix();
+        shader->set_uniform("view_model_matrix", view_matrix * trafo_matrix);
         shader->set_uniform("projection_matrix", camera.get_projection_matrix());
-        shader->set_uniform("normal_matrix", (Matrix3d)matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * trafo_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader->set_uniform("view_normal_matrix", view_normal_matrix);
 
         // For printers with multiple extruders, it is necessary to pass trafo_matrix
         // to the shader input variable print_box.volume_world_matrix before

src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp

@@ -415,19 +415,19 @@ void GLGizmoRotate::render_grabber_extension(const BoundingBoxf3& box, bool pick
     const Transform3d& view_matrix = camera.get_view_matrix();
     shader->set_uniform("projection_matrix", camera.get_projection_matrix());
 
-    Transform3d view_model_matrix = view_matrix * m_grabbers.front().matrix *
-        Geometry::assemble_transform(center, Vec3d(0.5 * PI, 0.0, m_angle)) *
-        Geometry::assemble_transform(1.5 * size * Vec3d::UnitZ(), Vec3d::Zero(), Vec3d(0.75 * size, 0.75 * size, 3.0 * size));
+    Transform3d model_matrix = m_grabbers.front().matrix * Geometry::assemble_transform(center, Vec3d(0.5 * PI, 0.0, m_angle)) *
+        Geometry::assemble_transform(2.0 * size * Vec3d::UnitZ(), Vec3d::Zero(), Vec3d(0.75 * size, 0.75 * size, 3.0 * size));
 
-    shader->set_uniform("view_model_matrix", view_model_matrix);
-    shader->set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+    shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
+    Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+    shader->set_uniform("view_normal_matrix", view_normal_matrix);
     m_cone.render();
-    view_model_matrix = view_matrix * m_grabbers.front().matrix *
-        Geometry::assemble_transform(center, Vec3d(-0.5 * PI, 0.0, m_angle)) *
-        Geometry::assemble_transform(1.5 * size * Vec3d::UnitZ(), Vec3d::Zero(), Vec3d(0.75 * size, 0.75 * size, 3.0 * size));
+    model_matrix = m_grabbers.front().matrix * Geometry::assemble_transform(center, Vec3d(-0.5 * PI, 0.0, m_angle)) *
+        Geometry::assemble_transform(2.0 * size * Vec3d::UnitZ(), Vec3d::Zero(), Vec3d(0.75 * size, 0.75 * size, 3.0 * size));
 
-    shader->set_uniform("view_model_matrix", view_model_matrix);
-    shader->set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+    shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
+    view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+    shader->set_uniform("view_normal_matrix", view_normal_matrix);
     m_cone.render();
 
     shader->stop_using();

src/slic3r/GUI/Gizmos/GLGizmoSeam.cpp

@@ -121,10 +121,11 @@ void GLGizmoSeam::render_triangles(const Selection& selection) const
             glsafe(::glFrontFace(GL_CW));
 
         const Camera& camera = wxGetApp().plater()->get_camera();
-        const Transform3d matrix = camera.get_view_matrix() * trafo_matrix;
-        shader->set_uniform("view_model_matrix", matrix);
+        const Transform3d& view_matrix = camera.get_view_matrix();
+        shader->set_uniform("view_model_matrix", view_matrix * trafo_matrix);
         shader->set_uniform("projection_matrix", camera.get_projection_matrix());
-        shader->set_uniform("normal_matrix", (Matrix3d)matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * trafo_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader->set_uniform("view_normal_matrix", view_normal_matrix);
 
         float normal_z = -::cos(Geometry::deg2rad(m_highlight_by_angle_threshold_deg));
         Matrix3f normal_matrix = static_cast<Matrix3f>(trafo_matrix.matrix().block(0, 0, 3, 3).inverse().transpose().cast<float>());

src/slic3r/GUI/Gizmos/GLGizmoSimplify.cpp

@@ -647,10 +647,12 @@ void GLGizmoSimplify::on_render()
     glsafe(::glEnable(GL_DEPTH_TEST));
     gouraud_shader->start_using();
     const Camera& camera = wxGetApp().plater()->get_camera();
-    const Transform3d view_model_matrix = camera.get_view_matrix() * trafo_matrix;
+    const Transform3d& view_matrix = camera.get_view_matrix();
+    const Transform3d view_model_matrix = view_matrix * trafo_matrix;
     gouraud_shader->set_uniform("view_model_matrix", view_model_matrix);
     gouraud_shader->set_uniform("projection_matrix", camera.get_projection_matrix());
-    gouraud_shader->set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+    const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * trafo_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+    gouraud_shader->set_uniform("view_normal_matrix", view_normal_matrix);
     m_glmodel.render();
     gouraud_shader->stop_using();
 

src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp

@@ -197,21 +197,23 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
             const Eigen::AngleAxisd aa(q);
             const double cone_radius = 0.25; // mm
             const double cone_height = 0.75;
-            const Transform3d view_model_matrix = view_matrix * instance_matrix * support_matrix * Transform3d(aa.toRotationMatrix()) *
+            const Transform3d model_matrix = instance_matrix * support_matrix * Transform3d(aa.toRotationMatrix()) *
                 Geometry::assemble_transform((cone_height + support_point.head_front_radius * RenderPointScale) * Vec3d::UnitZ(),
                     Vec3d(PI, 0.0, 0.0), Vec3d(cone_radius, cone_radius, cone_height));
 
-            shader->set_uniform("view_model_matrix", view_model_matrix);
-            shader->set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+            shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
+            const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+            shader->set_uniform("view_normal_matrix", view_normal_matrix);
             m_cone.render();
         }
 
         const double radius = (double)support_point.head_front_radius * RenderPointScale;
-        const Transform3d view_model_matrix = view_matrix * instance_matrix * support_matrix *
+        const Transform3d model_matrix = instance_matrix * support_matrix *
             Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), radius * Vec3d::Ones());
 
-        shader->set_uniform("view_model_matrix", view_model_matrix);
-        shader->set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
+        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader->set_uniform("view_normal_matrix", view_normal_matrix);
         m_sphere.render();
 
         if (vol->is_left_handed())
@@ -236,11 +238,12 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
             Eigen::Quaterniond q;
             q.setFromTwoVectors(Vec3d::UnitZ(), instance_scaling_matrix_inverse * (-drain_hole.normal).cast<double>());
             const Eigen::AngleAxisd aa(q);
-            const Transform3d view_model_matrix = view_matrix * instance_matrix * hole_matrix * Transform3d(aa.toRotationMatrix()) *
+            const Transform3d model_matrix = instance_matrix * hole_matrix * Transform3d(aa.toRotationMatrix()) *
                 Geometry::assemble_transform(-drain_hole.height * Vec3d::UnitZ(), Vec3d::Zero(), Vec3d(drain_hole.radius, drain_hole.radius, drain_hole.height + sla::HoleStickOutLength));
 
-            shader->set_uniform("view_model_matrix", view_model_matrix);
-            shader->set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+            shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
+            const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+            shader->set_uniform("view_normal_matrix", view_normal_matrix);
             m_cylinder.render();
 
             if (vol->is_left_handed())

src/slic3r/GUI/Selection.cpp

@@ -2252,26 +2252,28 @@ static ColorRGBA get_color(Axis axis)
 void Selection::render_sidebar_position_hints(const std::string& sidebar_field, GLShaderProgram& shader, const Transform3d& matrix)
 {
     const Camera& camera = wxGetApp().plater()->get_camera();
-    const Transform3d view_matrix = camera.get_view_matrix() * matrix;
+    const Transform3d& view_matrix = camera.get_view_matrix();
     shader.set_uniform("projection_matrix", camera.get_projection_matrix());
 
     if (boost::ends_with(sidebar_field, "x")) {
-        const Transform3d view_model_matrix = view_matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitZ());
-        shader.set_uniform("view_model_matrix", view_model_matrix);
-        shader.set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        const Transform3d model_matrix = matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitZ());
+        shader.set_uniform("view_model_matrix", view_matrix * model_matrix);
+        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader.set_uniform("view_normal_matrix", view_normal_matrix);
         m_arrow.set_color(get_color(X));
         m_arrow.render();
     }
     else if (boost::ends_with(sidebar_field, "y")) {
-        shader.set_uniform("view_model_matrix", view_matrix);
-        shader.set_uniform("normal_matrix", (Matrix3d)view_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        shader.set_uniform("view_model_matrix", view_matrix * matrix);
+        shader.set_uniform("view_normal_matrix", (Matrix3d)Matrix3d::Identity());
         m_arrow.set_color(get_color(Y));
         m_arrow.render();
     }
     else if (boost::ends_with(sidebar_field, "z")) {
-        const Transform3d view_model_matrix = view_matrix * Geometry::assemble_transform(Vec3d::Zero(), 0.5 * PI * Vec3d::UnitX());
-        shader.set_uniform("view_model_matrix", view_model_matrix);
-        shader.set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        const Transform3d model_matrix = matrix * Geometry::assemble_transform(Vec3d::Zero(), 0.5 * PI * Vec3d::UnitX());
+        shader.set_uniform("view_model_matrix", view_matrix * model_matrix);
+        const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader.set_uniform("view_normal_matrix", view_normal_matrix);
         m_arrow.set_color(get_color(Z));
         m_arrow.render();
     }
@@ -2279,32 +2281,33 @@ void Selection::render_sidebar_position_hints(const std::string& sidebar_field,
 
 void Selection::render_sidebar_rotation_hints(const std::string& sidebar_field, GLShaderProgram& shader, const Transform3d& matrix)
 {
-    auto render_sidebar_rotation_hint = [this](GLShaderProgram& shader, const Transform3d& matrix) {
-        Transform3d view_model_matrix = matrix;
-        shader.set_uniform("view_model_matrix", view_model_matrix);
-        shader.set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+    auto render_sidebar_rotation_hint = [this](GLShaderProgram& shader, const Transform3d& view_matrix, const Transform3d& model_matrix) {
+        shader.set_uniform("view_model_matrix", view_matrix * model_matrix);
+        Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader.set_uniform("view_normal_matrix", view_normal_matrix);
         m_curved_arrow.render();
-        view_model_matrix = matrix * Geometry::assemble_transform(Vec3d::Zero(), PI * Vec3d::UnitZ());
-        shader.set_uniform("view_model_matrix", view_model_matrix);
-        shader.set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        const Transform3d matrix = model_matrix * Geometry::assemble_transform(Vec3d::Zero(), PI * Vec3d::UnitZ());
+        shader.set_uniform("view_model_matrix", view_matrix * matrix);
+        view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader.set_uniform("view_normal_matrix", view_normal_matrix);
         m_curved_arrow.render();
     };
 
     const Camera& camera = wxGetApp().plater()->get_camera();
-    const Transform3d view_matrix = camera.get_view_matrix() * matrix;
+    const Transform3d& view_matrix = camera.get_view_matrix();
     shader.set_uniform("projection_matrix", camera.get_projection_matrix());
 
     if (boost::ends_with(sidebar_field, "x")) {
         m_curved_arrow.set_color(get_color(X));
-        render_sidebar_rotation_hint(shader, view_matrix * Geometry::assemble_transform(Vec3d::Zero(), 0.5 * PI * Vec3d::UnitY()));
+        render_sidebar_rotation_hint(shader, view_matrix, matrix * Geometry::assemble_transform(Vec3d::Zero(), 0.5 * PI * Vec3d::UnitY()));
     }
     else if (boost::ends_with(sidebar_field, "y")) {
         m_curved_arrow.set_color(get_color(Y));
-        render_sidebar_rotation_hint(shader, view_matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitX()));
+        render_sidebar_rotation_hint(shader, view_matrix, matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitX()));
     }
     else if (boost::ends_with(sidebar_field, "z")) {
         m_curved_arrow.set_color(get_color(Z));
-        render_sidebar_rotation_hint(shader, view_matrix);
+        render_sidebar_rotation_hint(shader, view_matrix, matrix);
     }
 }
 
@@ -2315,33 +2318,35 @@ void Selection::render_sidebar_scale_hints(const std::string& sidebar_field, boo
     //bool uniform_scale = requires_uniform_scale() || wxGetApp().obj_manipul()->get_uniform_scaling();
     bool uniform_scale = requires_uniform_scale() || gizmo_uniform_scale;
 
-    auto render_sidebar_scale_hint = [this, uniform_scale](Axis axis, GLShaderProgram& shader, const Transform3d& matrix) {
+    auto render_sidebar_scale_hint = [this, uniform_scale](Axis axis, GLShaderProgram& shader, const Transform3d& view_matrix, const Transform3d& model_matrix) {
         m_arrow.set_color(uniform_scale ? UNIFORM_SCALE_COLOR : get_color(axis));
-        Transform3d view_model_matrix = matrix * Geometry::assemble_transform(5.0 * Vec3d::UnitY());
-        shader.set_uniform("view_model_matrix", view_model_matrix);
-        shader.set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        Transform3d matrix = model_matrix * Geometry::assemble_transform(5.0 * Vec3d::UnitY());
+        shader.set_uniform("view_model_matrix", view_matrix * matrix);
+        Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader.set_uniform("view_normal_matrix", view_normal_matrix);
         m_arrow.render();
 
-        view_model_matrix = matrix * Geometry::assemble_transform(-5.0 * Vec3d::UnitY(), PI * Vec3d::UnitZ());
-        shader.set_uniform("view_model_matrix", view_model_matrix);
-        shader.set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
+        matrix = model_matrix * Geometry::assemble_transform(-5.0 * Vec3d::UnitY(), PI * Vec3d::UnitZ());
+        shader.set_uniform("view_model_matrix", view_matrix * matrix);
+        view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) * matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
+        shader.set_uniform("view_normal_matrix", view_normal_matrix);
         m_arrow.render();
     };
 
     const Camera& camera = wxGetApp().plater()->get_camera();
-    const Transform3d view_matrix = camera.get_view_matrix() * matrix;
+    const Transform3d& view_matrix = camera.get_view_matrix();
     shader.set_uniform("projection_matrix", camera.get_projection_matrix());
 
     if (boost::ends_with(sidebar_field, "x") || uniform_scale) {
-        render_sidebar_scale_hint(X, shader, view_matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitZ()));
+        render_sidebar_scale_hint(X, shader, view_matrix, matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitZ()));
     }
 
     if (boost::ends_with(sidebar_field, "y") || uniform_scale) {
-        render_sidebar_scale_hint(Y, shader, view_matrix);
+        render_sidebar_scale_hint(Y, shader, view_matrix, matrix);
     }
 
     if (boost::ends_with(sidebar_field, "z") || uniform_scale) {
-        render_sidebar_scale_hint(Z, shader, view_matrix * Geometry::assemble_transform(Vec3d::Zero(), 0.5 * PI * Vec3d::UnitX()));
+        render_sidebar_scale_hint(Z, shader, view_matrix, matrix * Geometry::assemble_transform(Vec3d::Zero(), 0.5 * PI * Vec3d::UnitX()));
     }
 }