GitHub-Proxy/PrusaSlicer
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/prusa3d/PrusaSlicer.git synced 2025-06-04 11:14:17 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Tech ENABLE_LEGACY_OPENGL_REMOVAL - Fixed calculation of normal matrices sent to shaders

Browse Source 
Fixed conflicts during rebase with master
This commit is contained in:
enricoturri1966 2022-04-21 13:58:04 +02:00
parent 1d5be00acf
commit c468dcbed7
25 changed files with 767 additions and 731 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
resources/shaders/110/gouraud.vs
View File

@ -27,7 +27,7 @@ struct SlopeDetection
uniform mat4 view_model_matrix; uniform mat4 view_model_matrix;
uniform mat4 projection_matrix; uniform mat4 projection_matrix;
uniform mat3 normal_matrix; uniform mat3 view_normal_matrix;
uniform mat4 volume_world_matrix; uniform mat4 volume_world_matrix;
uniform SlopeDetection slope; uniform SlopeDetection slope;
@ -51,7 +51,7 @@ varying vec3 eye_normal;
void main() void main()
{ {
// First transform the normal into camera space and normalize the result. // 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. // 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. // Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.

4
resources/shaders/110/gouraud_light.vs
View File

@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
uniform mat4 view_model_matrix; uniform mat4 view_model_matrix;
uniform mat4 projection_matrix; uniform mat4 projection_matrix;
uniform mat3 normal_matrix; uniform mat3 view_normal_matrix;
attribute vec3 v_position; attribute vec3 v_position;
attribute vec3 v_normal; attribute vec3 v_normal;
@ -27,7 +27,7 @@ varying vec2 intensity;
void main() void main()
{ {
// First transform the normal into camera space and normalize the result. // 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. // 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. // Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.

4
resources/shaders/110/gouraud_light_instanced.vs
View File

@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
uniform mat4 view_model_matrix; uniform mat4 view_model_matrix;
uniform mat4 projection_matrix; uniform mat4 projection_matrix;
uniform mat3 normal_matrix; uniform mat3 view_normal_matrix;
// vertex attributes // vertex attributes
attribute vec3 v_position; attribute vec3 v_position;
@ -31,7 +31,7 @@ varying vec2 intensity;
void main() void main()
{ {
// First transform the normal into camera space and normalize the result. // 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. // 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. // Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.

4
resources/shaders/110/mm_gouraud.fs
View File

@ -22,7 +22,7 @@ uniform vec4 uniform_color;
uniform bool volume_mirrored; uniform bool volume_mirrored;
uniform mat4 view_model_matrix; uniform mat4 view_model_matrix;
uniform mat3 normal_matrix; uniform mat3 view_normal_matrix;
varying vec3 clipping_planes_dots; varying vec3 clipping_planes_dots;
varying vec4 model_pos; varying vec4 model_pos;
@ -43,7 +43,7 @@ void main()
triangle_normal = -triangle_normal; triangle_normal = -triangle_normal;
// First transform the normal into camera space and normalize the result. // 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. // 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. // Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.

4
resources/shaders/110/toolpaths_cog.vs
View File

@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
uniform mat4 view_model_matrix; uniform mat4 view_model_matrix;
uniform mat4 projection_matrix; uniform mat4 projection_matrix;
uniform mat3 normal_matrix; uniform mat3 view_normal_matrix;
attribute vec3 v_position; attribute vec3 v_position;
attribute vec3 v_normal; attribute vec3 v_normal;
@ -28,7 +28,7 @@ varying vec3 world_position;
void main() void main()
{ {
// First transform the normal into camera space and normalize the result. // 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. // 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. // Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.

4
resources/shaders/110/variable_layer_height.vs
View File

@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
uniform mat4 view_model_matrix; uniform mat4 view_model_matrix;
uniform mat4 projection_matrix; uniform mat4 projection_matrix;
uniform mat3 normal_matrix; uniform mat3 view_normal_matrix;
uniform mat4 volume_world_matrix; uniform mat4 volume_world_matrix;
uniform float object_max_z; uniform float object_max_z;
@ -38,7 +38,7 @@ void main()
// ===================================================== // =====================================================
// First transform the normal into camera space and normalize the result. // 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. // 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. // Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.

4
resources/shaders/140/gouraud.vs
View File

@ -27,7 +27,7 @@ struct SlopeDetection
uniform mat4 view_model_matrix; uniform mat4 view_model_matrix;
uniform mat4 projection_matrix; uniform mat4 projection_matrix;
uniform mat3 normal_matrix; uniform mat3 view_normal_matrix;
uniform mat4 volume_world_matrix; uniform mat4 volume_world_matrix;
uniform SlopeDetection slope; uniform SlopeDetection slope;
@ -51,7 +51,7 @@ out vec3 eye_normal;
void main() void main()
{ {
// First transform the normal into camera space and normalize the result. // 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. // 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. // Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.

4
resources/shaders/140/gouraud_light.vs
View File

@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
uniform mat4 view_model_matrix; uniform mat4 view_model_matrix;
uniform mat4 projection_matrix; uniform mat4 projection_matrix;
uniform mat3 normal_matrix; uniform mat3 view_normal_matrix;
in vec3 v_position; in vec3 v_position;
in vec3 v_normal; in vec3 v_normal;
@ -27,7 +27,7 @@ out vec2 intensity;
void main() void main()
{ {
// First transform the normal into camera space and normalize the result. // 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. // 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. // Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.

4
resources/shaders/140/gouraud_light_instanced.vs
View File

@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
uniform mat4 view_model_matrix; uniform mat4 view_model_matrix;
uniform mat4 projection_matrix; uniform mat4 projection_matrix;
uniform mat3 normal_matrix; uniform mat3 view_normal_matrix;
// vertex attributes // vertex attributes
in vec3 v_position; in vec3 v_position;
@ -31,7 +31,7 @@ out vec2 intensity;
void main() void main()
{ {
// First transform the normal into camera space and normalize the result. // 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. // 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. // Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.

4
resources/shaders/140/mm_gouraud.fs
View File

@ -22,7 +22,7 @@ uniform vec4 uniform_color;
uniform bool volume_mirrored; uniform bool volume_mirrored;
uniform mat4 view_model_matrix; uniform mat4 view_model_matrix;
uniform mat3 normal_matrix; uniform mat3 view_normal_matrix;
in vec3 clipping_planes_dots; in vec3 clipping_planes_dots;
in vec4 model_pos; in vec4 model_pos;
@ -45,7 +45,7 @@ void main()
triangle_normal = -triangle_normal; triangle_normal = -triangle_normal;
// First transform the normal into camera space and normalize the result. // 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. // 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. // Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.

4
resources/shaders/140/toolpaths_cog.vs
View File

@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
uniform mat4 view_model_matrix; uniform mat4 view_model_matrix;
uniform mat4 projection_matrix; uniform mat4 projection_matrix;
uniform mat3 normal_matrix; uniform mat3 view_normal_matrix;
in vec3 v_position; in vec3 v_position;
in vec3 v_normal; in vec3 v_normal;
@ -28,7 +28,7 @@ out vec3 world_position;
void main() void main()
{ {
// First transform the normal into camera space and normalize the result. // 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. // 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. // Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.

4
resources/shaders/140/variable_layer_height.vs
View File

@ -16,7 +16,7 @@ const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
uniform mat4 view_model_matrix; uniform mat4 view_model_matrix;
uniform mat4 projection_matrix; uniform mat4 projection_matrix;
uniform mat3 normal_matrix; uniform mat3 view_normal_matrix;
uniform mat4 volume_world_matrix; uniform mat4 volume_world_matrix;
uniform float object_max_z; uniform float object_max_z;
@ -38,7 +38,7 @@ void main()
// ===================================================== // =====================================================
// First transform the normal into camera space and normalize the result. // 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. // 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. // Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.

14
src/slic3r/GUI/3DBed.cpp
View File

@ -112,10 +112,11 @@ void Bed3D::Axes::render()
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
auto render_axis = [this](GLShaderProgram* shader, const Transform3d& transform) { auto render_axis = [this](GLShaderProgram* shader, const Transform3d& transform) {
const Camera& camera = wxGetApp().plater()->get_camera(); const Camera& camera = wxGetApp().plater()->get_camera();
const Transform3d matrix = camera.get_view_matrix() * transform; const Transform3d& view_matrix = camera.get_view_matrix();
shader->set_uniform("view_model_matrix", matrix); shader->set_uniform("view_model_matrix", view_matrix * transform);
shader->set_uniform("projection_matrix", camera.get_projection_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) * transform.matrix().block(0, 0, 3, 3).inverse().transpose();
shader->set_uniform("view_normal_matrix", view_normal_matrix);
#else #else
auto render_axis = [this](const Transform3f& transform) { auto render_axis = [this](const Transform3f& transform) {
glsafe(::glPushMatrix()); glsafe(::glPushMatrix());
@ -776,10 +777,11 @@ void Bed3D::render_model()
shader->start_using(); shader->start_using();
shader->set_uniform("emission_factor", 0.0f); shader->set_uniform("emission_factor", 0.0f);
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
const Transform3d matrix = view_matrix * Geometry::assemble_transform(m_model_offset); const Transform3d model_matrix = Geometry::assemble_transform(m_model_offset);
shader->set_uniform("view_model_matrix", matrix); shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
shader->set_uniform("projection_matrix", projection_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);
#else #else
glsafe(::glPushMatrix()); glsafe(::glPushMatrix());
glsafe(::glTranslated(m_model_offset.x(), m_model_offset.y(), m_model_offset.z())); glsafe(::glTranslated(m_model_offset.x(), m_model_offset.y(), m_model_offset.z()));

7
src/slic3r/GUI/3DScene.cpp
View File

@ -1153,10 +1153,11 @@ void GLVolumeCollection::render(GLVolumeCollection::ERenderType type, bool disab
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
volume.first->model.set_color(volume.first->render_color); volume.first->model.set_color(volume.first->render_color);
const Transform3d matrix = view_matrix * volume.first->world_matrix(); const Transform3d model_matrix = volume.first->world_matrix();
shader->set_uniform("view_model_matrix", matrix); shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
shader->set_uniform("projection_matrix", projection_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);
#else #else
shader->set_uniform("uniform_color", volume.first->render_color); shader->set_uniform("uniform_color", volume.first->render_color);
#endif // ENABLE_LEGACY_OPENGL_REMOVAL #endif // ENABLE_LEGACY_OPENGL_REMOVAL

28
src/slic3r/GUI/GCodeViewer.cpp
View File

@ -202,14 +202,16 @@ void GCodeViewer::COG::render()
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
const Camera& camera = wxGetApp().plater()->get_camera(); const Camera& camera = wxGetApp().plater()->get_camera();
Transform3d matrix = camera.get_view_matrix() * Geometry::assemble_transform(cog()); Transform3d model_matrix = Geometry::assemble_transform(cog());
if (m_fixed_size) { if (m_fixed_size) {
const double inv_zoom = camera.get_inv_zoom(); const double inv_zoom = camera.get_inv_zoom();
matrix = matrix * Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), inv_zoom * Vec3d::Ones()); model_matrix = model_matrix * Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), inv_zoom * Vec3d::Ones());
} }
shader->set_uniform("view_model_matrix", matrix); 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()); 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(); m_model.render();
#else #else
glsafe(::glPushMatrix()); glsafe(::glPushMatrix());
@ -349,10 +351,12 @@ void GCodeViewer::SequentialView::Marker::render()
shader->set_uniform("emission_factor", 0.0f); shader->set_uniform("emission_factor", 0.0f);
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
const Camera& camera = wxGetApp().plater()->get_camera(); const Camera& camera = wxGetApp().plater()->get_camera();
const Transform3d matrix = camera.get_view_matrix() * m_world_transform.cast<double>(); const Transform3d& view_matrix = camera.get_view_matrix();
shader->set_uniform("view_model_matrix", 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("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);
#else #else
glsafe(::glPushMatrix()); glsafe(::glPushMatrix());
glsafe(::glMultMatrixf(m_world_transform.data())); glsafe(::glMultMatrixf(m_world_transform.data()));
@ -3194,10 +3198,9 @@ void GCodeViewer::render_toolpaths()
shader->start_using(); shader->start_using();
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
const Transform3d& view_matrix = camera.get_view_matrix(); shader->set_uniform("view_model_matrix", camera.get_view_matrix());
shader->set_uniform("view_model_matrix", view_matrix);
shader->set_uniform("projection_matrix", camera.get_projection_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());
#endif // ENABLE_LEGACY_OPENGL_REMOVAL #endif // ENABLE_LEGACY_OPENGL_REMOVAL
if (buffer.render_primitive_type == TBuffer::ERenderPrimitiveType::InstancedModel) { if (buffer.render_primitive_type == TBuffer::ERenderPrimitiveType::InstancedModel) {
@ -3317,10 +3320,9 @@ void GCodeViewer::render_toolpaths()
shader->start_using(); shader->start_using();
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
const Transform3d& view_matrix = camera.get_view_matrix(); shader->set_uniform("view_model_matrix", camera.get_view_matrix());
shader->set_uniform("view_model_matrix", view_matrix);
shader->set_uniform("projection_matrix", camera.get_projection_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 position_id = shader->get_attrib_location("v_position");
const int normal_id = shader->get_attrib_location("v_normal"); const int normal_id = shader->get_attrib_location("v_normal");

17
src/slic3r/GUI/GLCanvas3D.cpp
View File

@ -376,7 +376,7 @@ void GLCanvas3D::LayersEditing::render_active_object_annotations(const GLCanvas3
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
shader->set_uniform("view_model_matrix", Transform3d::Identity()); shader->set_uniform("view_model_matrix", Transform3d::Identity());
shader->set_uniform("projection_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());
#endif // ENABLE_LEGACY_OPENGL_REMOVAL #endif // ENABLE_LEGACY_OPENGL_REMOVAL
glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1)); glsafe(::glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
@ -589,9 +589,11 @@ void GLCanvas3D::LayersEditing::render_volumes(const GLCanvas3D& canvas, const G
shader->set_uniform("volume_world_matrix", glvolume->world_matrix()); shader->set_uniform("volume_world_matrix", glvolume->world_matrix());
shader->set_uniform("object_max_z", 0.0f); shader->set_uniform("object_max_z", 0.0f);
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
const Transform3d view_model_matrix = camera.get_view_matrix() * glvolume->world_matrix(); const Transform3d& view_matrix = camera.get_view_matrix();
shader->set_uniform("view_model_matrix", view_model_matrix); const Transform3d model_matrix = glvolume->world_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);
#endif // ENABLE_LEGACY_OPENGL_REMOVAL #endif // ENABLE_LEGACY_OPENGL_REMOVAL
glvolume->render(); glvolume->render();
@ -4592,10 +4594,11 @@ void GLCanvas3D::_render_thumbnail_internal(ThumbnailData& thumbnail_data, const
const bool is_active = vol->is_active; const bool is_active = vol->is_active;
vol->is_active = true; vol->is_active = true;
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
const Transform3d matrix = view_matrix * vol->world_matrix(); const Transform3d model_matrix = vol->world_matrix();
shader->set_uniform("view_model_matrix", matrix); shader->set_uniform("view_model_matrix", view_matrix * model_matrix);
shader->set_uniform("projection_matrix", projection_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);
#endif // ENABLE_LEGACY_OPENGL_REMOVAL #endif // ENABLE_LEGACY_OPENGL_REMOVAL
vol->render(); vol->render();
vol->is_active = is_active; vol->is_active = is_active;

13
src/slic3r/GUI/Gizmos/GLGizmoBase.cpp
View File

@ -92,6 +92,19 @@ void GLGizmoBase::Grabber::render(float size, const ColorRGBA& render_color, boo
#else #else
m_cube.set_color(render_color); m_cube.set_color(render_color);
#endif // ENABLE_GIZMO_GRABBER_REFACTOR #endif // ENABLE_GIZMO_GRABBER_REFACTOR
const Camera& camera = wxGetApp().plater()->get_camera();
const Transform3d& view_matrix = camera.get_view_matrix();
#if ENABLE_GIZMO_GRABBER_REFACTOR
const Transform3d model_matrix = matrix * Geometry::assemble_transform(center, angles, 2.0 * half_size * Vec3d::Ones());
#else
const Transform3d model_matrix = matrix * Geometry::assemble_transform(center, angles, fullsize * Vec3d::Ones());
#endif // ENABLE_GIZMO_GRABBER_REFACTOR
const Transform3d view_model_matrix = view_matrix * model_matrix;
shader->set_uniform("view_model_matrix", view_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);
#else #else
#if ENABLE_GIZMO_GRABBER_REFACTOR #if ENABLE_GIZMO_GRABBER_REFACTOR
s_cube.set_color(-1, render_color); s_cube.set_color(-1, render_color);

8
src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp
View File

@ -184,11 +184,11 @@ void GLGizmoHollow::render_points(const Selection& selection, bool picking)
q.setFromTwoVectors(Vec3d::UnitZ(), instance_scaling_matrix_inverse * (-drain_hole.normal).cast<double>()); q.setFromTwoVectors(Vec3d::UnitZ(), instance_scaling_matrix_inverse * (-drain_hole.normal).cast<double>());
const Eigen::AngleAxisd aa(q); const Eigen::AngleAxisd aa(q);
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
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)); 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_matrix * model_matrix);
shader->set_uniform("view_model_matrix", view_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("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose()); shader->set_uniform("view_normal_matrix", view_normal_matrix);
#else #else
glsafe(::glRotated(aa.angle() * (180. / M_PI), aa.axis().x(), aa.axis().y(), aa.axis().z())); glsafe(::glRotated(aa.angle() * (180. / M_PI), aa.axis().x(), aa.axis().y(), aa.axis().z()));
glsafe(::glTranslated(0., 0., -drain_hole.height)); glsafe(::glTranslated(0., 0., -drain_hole.height));

14
src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.cpp
View File

@ -195,10 +195,11 @@ void GLGizmoMmuSegmentation::render_triangles(const Selection &selection) const
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
const Camera& camera = wxGetApp().plater()->get_camera(); const Camera& camera = wxGetApp().plater()->get_camera();
const Transform3d matrix = camera.get_view_matrix() * trafo_matrix; const Transform3d& view_matrix = camera.get_view_matrix();
shader->set_uniform("view_model_matrix", matrix); shader->set_uniform("view_model_matrix", view_matrix * trafo_matrix);
shader->set_uniform("projection_matrix", camera.get_projection_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);
#else #else
glsafe(::glPushMatrix()); glsafe(::glPushMatrix());
glsafe(::glMultMatrixd(trafo_matrix.data())); glsafe(::glMultMatrixd(trafo_matrix.data()));
@ -596,10 +597,11 @@ void TriangleSelectorMmGui::render(ImGuiWrapper *imgui)
assert(shader->get_name() == "mm_gouraud"); assert(shader->get_name() == "mm_gouraud");
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
const Camera& camera = wxGetApp().plater()->get_camera(); const Camera& camera = wxGetApp().plater()->get_camera();
const Transform3d view_model_matrix = camera.get_view_matrix() * matrix; const Transform3d& view_matrix = camera.get_view_matrix();
shader->set_uniform("view_model_matrix", view_model_matrix); shader->set_uniform("view_model_matrix", view_matrix * matrix);
shader->set_uniform("projection_matrix", camera.get_projection_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) * matrix.matrix().block(0, 0, 3, 3).inverse().transpose();
shader->set_uniform("view_normal_matrix", view_normal_matrix);
#endif // ENABLE_LEGACY_OPENGL_REMOVAL #endif // ENABLE_LEGACY_OPENGL_REMOVAL
for (size_t color_idx = 0; color_idx < m_gizmo_scene.triangle_indices.size(); ++color_idx) { for (size_t color_idx = 0; color_idx < m_gizmo_scene.triangle_indices.size(); ++color_idx) {

14
src/slic3r/GUI/Gizmos/GLGizmoMove.cpp
View File

@ -320,16 +320,18 @@ void GLGizmoMove3D::render_grabber_extension(Axis axis, const BoundingBoxf3& box
shader->start_using(); shader->start_using();
shader->set_uniform("emission_factor", 0.1f); shader->set_uniform("emission_factor", 0.1f);
const Camera& camera = wxGetApp().plater()->get_camera(); 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) 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) else if (axis == Y)
view_model_matrix = view_model_matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitX()); model_matrix = model_matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitX());
view_model_matrix = view_model_matrix * Geometry::assemble_transform(2.0 * size * Vec3d::UnitZ(), Vec3d::Zero(), Vec3d(0.75 * size, 0.75 * size, 3.0 * size)); 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("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);
#else #else
m_cone.set_color(-1, (!picking && m_hover_id != -1) ? complementary(m_grabbers[axis].color) : m_grabbers[axis].color); m_cone.set_color(-1, (!picking && m_hover_id != -1) ? complementary(m_grabbers[axis].color) : m_grabbers[axis].color);
if (!picking) { if (!picking) {

7
src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp
View File

@ -108,10 +108,11 @@ void GLGizmoPainterBase::render_triangles(const Selection& selection) const
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
const Camera& camera = wxGetApp().plater()->get_camera(); const Camera& camera = wxGetApp().plater()->get_camera();
const Transform3d matrix = camera.get_view_matrix() * trafo_matrix; const Transform3d& view_matrix = camera.get_view_matrix();
shader->set_uniform("view_model_matrix", matrix); shader->set_uniform("view_model_matrix", view_matrix * trafo_matrix);
shader->set_uniform("projection_matrix", camera.get_projection_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);
#else #else
glsafe(::glPushMatrix()); glsafe(::glPushMatrix());
glsafe(::glMultMatrixd(trafo_matrix.data())); glsafe(::glMultMatrixd(trafo_matrix.data()));

16
src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp
View File

@ -619,12 +619,12 @@ void GLGizmoRotate::render_grabber_extension(const BoundingBoxf3& box, bool pick
const Transform3d& view_matrix = camera.get_view_matrix(); const Transform3d& view_matrix = camera.get_view_matrix();
shader->set_uniform("projection_matrix", camera.get_projection_matrix()); shader->set_uniform("projection_matrix", camera.get_projection_matrix());
Transform3d view_model_matrix = view_matrix * m_grabbers.front().matrix * Transform3d model_matrix = m_grabbers.front().matrix * Geometry::assemble_transform(center, Vec3d(0.5 * PI, 0.0, m_angle)) *
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)); 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("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose()); 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);
#else #else
glsafe(::glPushMatrix()); glsafe(::glPushMatrix());
glsafe(::glTranslated(center.x(), center.y(), center.z())); glsafe(::glTranslated(center.x(), center.y(), center.z()));
@ -635,12 +635,12 @@ void GLGizmoRotate::render_grabber_extension(const BoundingBoxf3& box, bool pick
#endif // ENABLE_LEGACY_OPENGL_REMOVAL #endif // ENABLE_LEGACY_OPENGL_REMOVAL
m_cone.render(); m_cone.render();
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
view_model_matrix = view_matrix * m_grabbers.front().matrix * model_matrix = m_grabbers.front().matrix * Geometry::assemble_transform(center, Vec3d(-0.5 * PI, 0.0, m_angle)) *
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)); 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("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose()); 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);
#else #else
glsafe(::glPopMatrix()); glsafe(::glPopMatrix());
glsafe(::glPushMatrix()); glsafe(::glPushMatrix());

6
src/slic3r/GUI/Gizmos/GLGizmoSimplify.cpp
View File

@ -752,10 +752,12 @@ void GLGizmoSimplify::on_render()
gouraud_shader->start_using(); gouraud_shader->start_using();
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
const Camera& camera = wxGetApp().plater()->get_camera(); 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("view_model_matrix", view_model_matrix);
gouraud_shader->set_uniform("projection_matrix", camera.get_projection_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);
#endif // ENABLE_LEGACY_OPENGL_REMOVAL #endif // ENABLE_LEGACY_OPENGL_REMOVAL
glmodel.render(); glmodel.render();
gouraud_shader->stop_using(); gouraud_shader->stop_using();

21
src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp
View File

@ -230,12 +230,13 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
const double cone_radius = 0.25; // mm const double cone_radius = 0.25; // mm
const double cone_height = 0.75; const double cone_height = 0.75;
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
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(), 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)); 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("view_model_matrix", view_matrix * model_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);
#else #else
glsafe(::glPushMatrix()); glsafe(::glPushMatrix());
glsafe(::glRotated(aa.angle() * (180. / M_PI), aa.axis().x(), aa.axis().y(), aa.axis().z())); glsafe(::glRotated(aa.angle() * (180. / M_PI), aa.axis().x(), aa.axis().y(), aa.axis().z()));
@ -251,11 +252,12 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
const double radius = (double)support_point.head_front_radius * RenderPointScale; const double radius = (double)support_point.head_front_radius * RenderPointScale;
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
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()); Geometry::assemble_transform(Vec3d::Zero(), Vec3d::Zero(), radius * Vec3d::Ones());
shader->set_uniform("view_model_matrix", view_model_matrix); shader->set_uniform("view_model_matrix", view_matrix * model_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);
#else #else
glsafe(::glPushMatrix()); glsafe(::glPushMatrix());
glsafe(::glScaled(radius, radius, radius)); glsafe(::glScaled(radius, radius, radius));
@ -304,11 +306,12 @@ void GLGizmoSlaSupports::render_points(const Selection& selection, bool picking)
q.setFromTwoVectors(Vec3d::UnitZ(), instance_scaling_matrix_inverse * (-drain_hole.normal).cast<double>()); q.setFromTwoVectors(Vec3d::UnitZ(), instance_scaling_matrix_inverse * (-drain_hole.normal).cast<double>());
const Eigen::AngleAxisd aa(q); const Eigen::AngleAxisd aa(q);
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
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)); 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("view_model_matrix", view_matrix * model_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);
#else #else
glsafe(::glRotated(aa.angle() * (180. / M_PI), aa.axis().x(), aa.axis().y(), aa.axis().z())); glsafe(::glRotated(aa.angle() * (180. / M_PI), aa.axis().x(), aa.axis().y(), aa.axis().z()));
glsafe(::glTranslated(0., 0., -drain_hole.height)); glsafe(::glTranslated(0., 0., -drain_hole.height));

67
src/slic3r/GUI/Selection.cpp
View File

@ -2078,26 +2078,28 @@ void Selection::render_sidebar_position_hints(const std::string& sidebar_field)
{ {
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
const Camera& camera = wxGetApp().plater()->get_camera(); 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()); shader.set_uniform("projection_matrix", camera.get_projection_matrix());
if (boost::ends_with(sidebar_field, "x")) { if (boost::ends_with(sidebar_field, "x")) {
const Transform3d view_model_matrix = view_matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitZ()); const Transform3d model_matrix = matrix * Geometry::assemble_transform(Vec3d::Zero(), -0.5 * PI * Vec3d::UnitZ());
shader.set_uniform("view_model_matrix", view_model_matrix); shader.set_uniform("view_model_matrix", view_matrix * model_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_arrow.set_color(get_color(X)); m_arrow.set_color(get_color(X));
m_arrow.render(); m_arrow.render();
} }
else if (boost::ends_with(sidebar_field, "y")) { else if (boost::ends_with(sidebar_field, "y")) {
shader.set_uniform("view_model_matrix", view_matrix); shader.set_uniform("view_model_matrix", view_matrix * 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());
m_arrow.set_color(get_color(Y)); m_arrow.set_color(get_color(Y));
m_arrow.render(); m_arrow.render();
} }
else if (boost::ends_with(sidebar_field, "z")) { 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()); const Transform3d model_matrix = matrix * Geometry::assemble_transform(Vec3d::Zero(), 0.5 * PI * Vec3d::UnitX());
shader.set_uniform("view_model_matrix", view_model_matrix); shader.set_uniform("view_model_matrix", view_matrix * model_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_arrow.set_color(get_color(Z)); m_arrow.set_color(get_color(Z));
m_arrow.render(); m_arrow.render();
} }
@ -2126,32 +2128,33 @@ void Selection::render_sidebar_rotation_hints(const std::string& sidebar_field)
#endif // ENABLE_LEGACY_OPENGL_REMOVAL #endif // ENABLE_LEGACY_OPENGL_REMOVAL
{ {
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
auto render_sidebar_rotation_hint = [this](GLShaderProgram& shader, const Transform3d& matrix) { auto render_sidebar_rotation_hint = [this](GLShaderProgram& shader, const Transform3d& view_matrix, const Transform3d& model_matrix) {
Transform3d view_model_matrix = matrix; shader.set_uniform("view_model_matrix", view_matrix * model_matrix);
shader.set_uniform("view_model_matrix", view_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("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose()); shader.set_uniform("view_normal_matrix", view_normal_matrix);
m_curved_arrow.render(); m_curved_arrow.render();
view_model_matrix = matrix * Geometry::assemble_transform(Vec3d::Zero(), PI * Vec3d::UnitZ()); const Transform3d matrix = model_matrix * Geometry::assemble_transform(Vec3d::Zero(), PI * Vec3d::UnitZ());
shader.set_uniform("view_model_matrix", view_model_matrix); shader.set_uniform("view_model_matrix", view_matrix * matrix);
shader.set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose()); 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(); m_curved_arrow.render();
}; };
const Camera& camera = wxGetApp().plater()->get_camera(); 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()); shader.set_uniform("projection_matrix", camera.get_projection_matrix());
if (boost::ends_with(sidebar_field, "x")) { if (boost::ends_with(sidebar_field, "x")) {
m_curved_arrow.set_color(get_color(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")) { else if (boost::ends_with(sidebar_field, "y")) {
m_curved_arrow.set_color(get_color(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")) { else if (boost::ends_with(sidebar_field, "z")) {
m_curved_arrow.set_color(get_color(Z)); m_curved_arrow.set_color(get_color(Z));
render_sidebar_rotation_hint(shader, view_matrix); render_sidebar_rotation_hint(shader, view_matrix, matrix);
} }
#else #else
auto render_sidebar_rotation_hint = [this]() { auto render_sidebar_rotation_hint = [this]() {
@ -2186,11 +2189,12 @@ void Selection::render_sidebar_scale_hints(const std::string& sidebar_field)
const bool uniform_scale = requires_uniform_scale() || wxGetApp().obj_manipul()->get_uniform_scaling(); const bool uniform_scale = requires_uniform_scale() || wxGetApp().obj_manipul()->get_uniform_scaling();
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
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)); m_arrow.set_color(uniform_scale ? UNIFORM_SCALE_COLOR : get_color(axis));
Transform3d view_model_matrix = matrix * Geometry::assemble_transform(5.0 * Vec3d::UnitY()); Transform3d matrix = model_matrix * Geometry::assemble_transform(5.0 * Vec3d::UnitY());
shader.set_uniform("view_model_matrix", view_model_matrix); shader.set_uniform("view_model_matrix", view_matrix * matrix);
shader.set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose()); 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);
#else #else
auto render_sidebar_scale_hint = [this, uniform_scale](Axis axis) { auto render_sidebar_scale_hint = [this, uniform_scale](Axis axis) {
m_arrow.set_color(-1, uniform_scale ? UNIFORM_SCALE_COLOR : get_color(axis)); m_arrow.set_color(-1, uniform_scale ? UNIFORM_SCALE_COLOR : get_color(axis));
@ -2203,9 +2207,10 @@ void Selection::render_sidebar_scale_hints(const std::string& sidebar_field)
m_arrow.render(); m_arrow.render();
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
view_model_matrix = matrix * Geometry::assemble_transform(-5.0 * Vec3d::UnitY(), PI * Vec3d::UnitZ()); matrix = model_matrix * Geometry::assemble_transform(-5.0 * Vec3d::UnitY(), PI * Vec3d::UnitZ());
shader.set_uniform("view_model_matrix", view_model_matrix); shader.set_uniform("view_model_matrix", view_matrix * matrix);
shader.set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose()); 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);
#else #else
glsafe(::glTranslated(0.0, -10.0, 0.0)); glsafe(::glTranslated(0.0, -10.0, 0.0));
glsafe(::glRotated(180.0, 0.0, 0.0, 1.0)); glsafe(::glRotated(180.0, 0.0, 0.0, 1.0));
@ -2215,13 +2220,13 @@ void Selection::render_sidebar_scale_hints(const std::string& sidebar_field)
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
const Camera& camera = wxGetApp().plater()->get_camera(); 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()); shader.set_uniform("projection_matrix", camera.get_projection_matrix());
#endif // ENABLE_LEGACY_OPENGL_REMOVAL #endif // ENABLE_LEGACY_OPENGL_REMOVAL
if (boost::ends_with(sidebar_field, "x") || uniform_scale) { if (boost::ends_with(sidebar_field, "x") || uniform_scale) {
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
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()));
#else #else
glsafe(::glPushMatrix()); glsafe(::glPushMatrix());
glsafe(::glRotated(-90.0, 0.0, 0.0, 1.0)); glsafe(::glRotated(-90.0, 0.0, 0.0, 1.0));
@ -2232,7 +2237,7 @@ void Selection::render_sidebar_scale_hints(const std::string& sidebar_field)
if (boost::ends_with(sidebar_field, "y") || uniform_scale) { if (boost::ends_with(sidebar_field, "y") || uniform_scale) {
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
render_sidebar_scale_hint(Y, shader, view_matrix); render_sidebar_scale_hint(Y, shader, view_matrix, matrix);
#else #else
glsafe(::glPushMatrix()); glsafe(::glPushMatrix());
render_sidebar_scale_hint(Y); render_sidebar_scale_hint(Y);
@ -2242,7 +2247,7 @@ void Selection::render_sidebar_scale_hints(const std::string& sidebar_field)
if (boost::ends_with(sidebar_field, "z") || uniform_scale) { if (boost::ends_with(sidebar_field, "z") || uniform_scale) {
#if ENABLE_LEGACY_OPENGL_REMOVAL #if ENABLE_LEGACY_OPENGL_REMOVAL
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()));
#else #else
glsafe(::glPushMatrix()); glsafe(::glPushMatrix());
glsafe(::glRotated(90.0, 1.0, 0.0, 0.0)); glsafe(::glRotated(90.0, 1.0, 0.0, 0.0));