3DPrinting/PrusaSlicer-NonPlainar
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

GCodeViewer -> New shaders for options

Browse Source
This commit is contained in:
enricoturri1966 2020-05-22 13:21:43 +02:00
parent 80c2f107c1
commit 4d05ec0856
18 changed files with 132 additions and 408 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
resources/shaders/colorchanges.fs
View File

@ -1,45 +0,0 @@
#version 110
#define INTENSITY_AMBIENT 0.3
#define INTENSITY_CORRECTION 0.6
// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31)
const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
#define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SHININESS 20.0
// normalized values for (1./1.43, 0.2/1.43, 1./1.43)
const vec3 LIGHT_FRONT_DIR = vec3(0.0, 0.0, 1.0);
#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION)
uniform vec3 uniform_color;
varying vec3 eye_position;
varying vec3 eye_normal;
//varying float world_normal_z;
// x = tainted, y = specular;
vec2 intensity;
void main()
{
vec3 normal = normalize(eye_normal);
// Compute the cos of the angle between the normal and lights direction. The light is directional so the direction is constant for every vertex.
// Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.
float NdotL = max(dot(normal, LIGHT_TOP_DIR), 0.0);
intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE;
intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(eye_position), reflect(-LIGHT_TOP_DIR, normal)), 0.0), LIGHT_TOP_SHININESS);
// Perform the same lighting calculation for the 2nd light source (no specular applied).
NdotL = max(dot(normal, LIGHT_FRONT_DIR), 0.0);
intensity.x += NdotL * LIGHT_FRONT_DIFFUSE;
// // darkens fragments whose normal points downward
// if (world_normal_z < 0.0)
// intensity.x *= (1.0 + world_normal_z * (1.0 - INTENSITY_AMBIENT));
gl_FragColor = vec4(vec3(intensity.y, intensity.y, intensity.y) + uniform_color * intensity.x, 1.0);
}

17
resources/shaders/colorchanges.vs
View File

@ -1,17 +0,0 @@
#version 110
varying vec3 eye_position;
varying vec3 eye_normal;
//// world z component of the normal used to darken the lower side of the toolpaths
//varying float world_normal_z;
void main()
{
eye_position = (gl_ModelViewMatrix * gl_Vertex).xyz;
eye_normal = gl_NormalMatrix * vec3(0.0, 0.0, 1.0);
// eye_normal = gl_NormalMatrix * gl_Normal;
// world_normal_z = gl_Normal.z;
gl_Position = ftransform();
gl_PointSize = 15.0;
}

45
resources/shaders/customs.fs
View File

@ -1,45 +0,0 @@
#version 110
#define INTENSITY_AMBIENT 0.3
#define INTENSITY_CORRECTION 0.6
// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31)
const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
#define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SHININESS 20.0
// normalized values for (1./1.43, 0.2/1.43, 1./1.43)
const vec3 LIGHT_FRONT_DIR = vec3(0.0, 0.0, 1.0);
#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION)
uniform vec3 uniform_color;
varying vec3 eye_position;
varying vec3 eye_normal;
//varying float world_normal_z;
// x = tainted, y = specular;
vec2 intensity;
void main()
{
vec3 normal = normalize(eye_normal);
// Compute the cos of the angle between the normal and lights direction. The light is directional so the direction is constant for every vertex.
// Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.
float NdotL = max(dot(normal, LIGHT_TOP_DIR), 0.0);
intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE;
intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(eye_position), reflect(-LIGHT_TOP_DIR, normal)), 0.0), LIGHT_TOP_SHININESS);
// Perform the same lighting calculation for the 2nd light source (no specular applied).
NdotL = max(dot(normal, LIGHT_FRONT_DIR), 0.0);
intensity.x += NdotL * LIGHT_FRONT_DIFFUSE;
// // darkens fragments whose normal points downward
// if (world_normal_z < 0.0)
// intensity.x *= (1.0 + world_normal_z * (1.0 - INTENSITY_AMBIENT));
gl_FragColor = vec4(vec3(intensity.y, intensity.y, intensity.y) + uniform_color * intensity.x, 1.0);
}

17
resources/shaders/customs.vs
View File

@ -1,17 +0,0 @@
#version 110
varying vec3 eye_position;
varying vec3 eye_normal;
//// world z component of the normal used to darken the lower side of the toolpaths
//varying float world_normal_z;
void main()
{
eye_position = (gl_ModelViewMatrix * gl_Vertex).xyz;
eye_normal = gl_NormalMatrix * vec3(0.0, 0.0, 1.0);
// eye_normal = gl_NormalMatrix * gl_Normal;
// world_normal_z = gl_Normal.z;
gl_Position = ftransform();
gl_PointSize = 15.0;
}

8
resources/shaders/options_110.fs Normal file
View File

@ -0,0 +1,8 @@
#version 120
uniform vec3 uniform_color;
void main()
{
gl_FragColor = vec4(uniform_color, 1.0);
}

11
resources/shaders/options_110.vs Normal file
View File

@ -0,0 +1,11 @@
#version 110
uniform float zoom;
// x = min, y = max
uniform vec2 point_sizes;
void main()
{
gl_PointSize = clamp(zoom, point_sizes.x, point_sizes.y);
gl_Position = ftransform();
}

15
resources/shaders/options_120.fs Normal file
View File

@ -0,0 +1,15 @@
#version 120
uniform vec3 uniform_color;
void main()
{
vec2 pos = gl_PointCoord - vec2(0.5, 0.5);
float sq_radius = pos.x * pos.x + pos.y * pos.y;
if (sq_radius > 0.25)
discard;
else if (sq_radius > 0.180625)
gl_FragColor = vec4(0.5 * uniform_color, 1.0);
else
gl_FragColor = vec4(uniform_color, 1.0);
}

11
resources/shaders/options_120.vs Normal file
View File

@ -0,0 +1,11 @@
#version 120
uniform float zoom;
// x = min, y = max
uniform vec2 point_sizes;
void main()
{
gl_PointSize = clamp(zoom, point_sizes.x, point_sizes.y);
gl_Position = ftransform();
}

45
resources/shaders/pauses.fs
View File

@ -1,45 +0,0 @@
#version 110
#define INTENSITY_AMBIENT 0.3
#define INTENSITY_CORRECTION 0.6
// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31)
const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
#define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SHININESS 20.0
// normalized values for (1./1.43, 0.2/1.43, 1./1.43)
const vec3 LIGHT_FRONT_DIR = vec3(0.0, 0.0, 1.0);
#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION)
uniform vec3 uniform_color;
varying vec3 eye_position;
varying vec3 eye_normal;
//varying float world_normal_z;
// x = tainted, y = specular;
vec2 intensity;
void main()
{
vec3 normal = normalize(eye_normal);
// Compute the cos of the angle between the normal and lights direction. The light is directional so the direction is constant for every vertex.
// Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.
float NdotL = max(dot(normal, LIGHT_TOP_DIR), 0.0);
intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE;
intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(eye_position), reflect(-LIGHT_TOP_DIR, normal)), 0.0), LIGHT_TOP_SHININESS);
// Perform the same lighting calculation for the 2nd light source (no specular applied).
NdotL = max(dot(normal, LIGHT_FRONT_DIR), 0.0);
intensity.x += NdotL * LIGHT_FRONT_DIFFUSE;
// // darkens fragments whose normal points downward
// if (world_normal_z < 0.0)
// intensity.x *= (1.0 + world_normal_z * (1.0 - INTENSITY_AMBIENT));
gl_FragColor = vec4(vec3(intensity.y, intensity.y, intensity.y) + uniform_color * intensity.x, 1.0);
}

17
resources/shaders/pauses.vs
View File

@ -1,17 +0,0 @@
#version 110
varying vec3 eye_position;
varying vec3 eye_normal;
//// world z component of the normal used to darken the lower side of the toolpaths
//varying float world_normal_z;
void main()
{
eye_position = (gl_ModelViewMatrix * gl_Vertex).xyz;
eye_normal = gl_NormalMatrix * vec3(0.0, 0.0, 1.0);
// eye_normal = gl_NormalMatrix * gl_Normal;
// world_normal_z = gl_Normal.z;
gl_Position = ftransform();
gl_PointSize = 15.0;
}

45
resources/shaders/retractions.fs
View File

@ -1,45 +0,0 @@
#version 110
#define INTENSITY_AMBIENT 0.3
#define INTENSITY_CORRECTION 0.6
// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31)
const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
#define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SHININESS 20.0
// normalized values for (1./1.43, 0.2/1.43, 1./1.43)
const vec3 LIGHT_FRONT_DIR = vec3(0.0, 0.0, 1.0);
#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION)
uniform vec3 uniform_color;
varying vec3 eye_position;
varying vec3 eye_normal;
//varying float world_normal_z;
// x = tainted, y = specular;
vec2 intensity;
void main()
{
vec3 normal = normalize(eye_normal);
// Compute the cos of the angle between the normal and lights direction. The light is directional so the direction is constant for every vertex.
// Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.
float NdotL = max(dot(normal, LIGHT_TOP_DIR), 0.0);
intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE;
intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(eye_position), reflect(-LIGHT_TOP_DIR, normal)), 0.0), LIGHT_TOP_SHININESS);
// Perform the same lighting calculation for the 2nd light source (no specular applied).
NdotL = max(dot(normal, LIGHT_FRONT_DIR), 0.0);
intensity.x += NdotL * LIGHT_FRONT_DIFFUSE;
// // darkens fragments whose normal points downward
// if (world_normal_z < 0.0)
// intensity.x *= (1.0 + world_normal_z * (1.0 - INTENSITY_AMBIENT));
gl_FragColor = vec4(vec3(intensity.y, intensity.y, intensity.y) + uniform_color * intensity.x, 1.0);
}

17
resources/shaders/retractions.vs
View File

@ -1,17 +0,0 @@
#version 110
varying vec3 eye_position;
varying vec3 eye_normal;
//// world z component of the normal used to darken the lower side of the toolpaths
//varying float world_normal_z;
void main()
{
eye_position = (gl_ModelViewMatrix * gl_Vertex).xyz;
eye_normal = gl_NormalMatrix * vec3(0.0, 0.0, 1.0);
// eye_normal = gl_NormalMatrix * gl_Normal;
// world_normal_z = gl_Normal.z;
gl_Position = ftransform();
gl_PointSize = 15.0;
}

45
resources/shaders/toolchanges.fs
View File

@ -1,45 +0,0 @@
#version 110
#define INTENSITY_AMBIENT 0.3
#define INTENSITY_CORRECTION 0.6
// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31)
const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
#define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SHININESS 20.0
// normalized values for (1./1.43, 0.2/1.43, 1./1.43)
const vec3 LIGHT_FRONT_DIR = vec3(0.0, 0.0, 1.0);
#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION)
uniform vec3 uniform_color;
varying vec3 eye_position;
varying vec3 eye_normal;
//varying float world_normal_z;
// x = tainted, y = specular;
vec2 intensity;
void main()
{
vec3 normal = normalize(eye_normal);
// Compute the cos of the angle between the normal and lights direction. The light is directional so the direction is constant for every vertex.
// Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.
float NdotL = max(dot(normal, LIGHT_TOP_DIR), 0.0);
intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE;
intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(eye_position), reflect(-LIGHT_TOP_DIR, normal)), 0.0), LIGHT_TOP_SHININESS);
// Perform the same lighting calculation for the 2nd light source (no specular applied).
NdotL = max(dot(normal, LIGHT_FRONT_DIR), 0.0);
intensity.x += NdotL * LIGHT_FRONT_DIFFUSE;
// // darkens fragments whose normal points downward
// if (world_normal_z < 0.0)
// intensity.x *= (1.0 + world_normal_z * (1.0 - INTENSITY_AMBIENT));
gl_FragColor = vec4(vec3(intensity.y, intensity.y, intensity.y) + uniform_color * intensity.x, 1.0);
}

17
resources/shaders/toolchanges.vs
View File

@ -1,17 +0,0 @@
#version 110
varying vec3 eye_position;
varying vec3 eye_normal;
//// world z component of the normal used to darken the lower side of the toolpaths
//varying float world_normal_z;
void main()
{
eye_position = (gl_ModelViewMatrix * gl_Vertex).xyz;
eye_normal = gl_NormalMatrix * vec3(0.0, 0.0, 1.0);
// eye_normal = gl_NormalMatrix * gl_Normal;
// world_normal_z = gl_Normal.z;
gl_Position = ftransform();
gl_PointSize = 15.0;
}

45
resources/shaders/unretractions.fs
View File

@ -1,45 +0,0 @@
#version 110
#define INTENSITY_AMBIENT 0.3
#define INTENSITY_CORRECTION 0.6
// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31)
const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
#define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION)
#define LIGHT_TOP_SHININESS 20.0
// normalized values for (1./1.43, 0.2/1.43, 1./1.43)
const vec3 LIGHT_FRONT_DIR = vec3(0.0, 0.0, 1.0);
#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION)
uniform vec3 uniform_color;
varying vec3 eye_position;
varying vec3 eye_normal;
//varying float world_normal_z;
// x = tainted, y = specular;
vec2 intensity;
void main()
{
vec3 normal = normalize(eye_normal);
// Compute the cos of the angle between the normal and lights direction. The light is directional so the direction is constant for every vertex.
// Since these two are normalized the cosine is the dot product. We also need to clamp the result to the [0,1] range.
float NdotL = max(dot(normal, LIGHT_TOP_DIR), 0.0);
intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE;
intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(eye_position), reflect(-LIGHT_TOP_DIR, normal)), 0.0), LIGHT_TOP_SHININESS);
// Perform the same lighting calculation for the 2nd light source (no specular applied).
NdotL = max(dot(normal, LIGHT_FRONT_DIR), 0.0);
intensity.x += NdotL * LIGHT_FRONT_DIFFUSE;
// // darkens fragments whose normal points downward
// if (world_normal_z < 0.0)
// intensity.x *= (1.0 + world_normal_z * (1.0 - INTENSITY_AMBIENT));
gl_FragColor = vec4(vec3(intensity.y, intensity.y, intensity.y) + uniform_color * intensity.x, 1.0);
}

17
resources/shaders/unretractions.vs
View File

@ -1,17 +0,0 @@
#version 110
varying vec3 eye_position;
varying vec3 eye_normal;
//// world z component of the normal used to darken the lower side of the toolpaths
//varying float world_normal_z;
void main()
{
eye_position = (gl_ModelViewMatrix * gl_Vertex).xyz;
eye_normal = gl_NormalMatrix * vec3(0.0, 0.0, 1.0);
// eye_normal = gl_NormalMatrix * gl_Normal;
// world_normal_z = gl_Normal.z;
gl_Position = ftransform();
gl_PointSize = 15.0;
}

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

@ -440,12 +440,12 @@ void GCodeViewer::init_shaders()
{
switch (buffer_type(i))
{
case GCodeProcessor::EMoveType::Tool_change: { m_buffers[i].shader = "toolchanges"; break; }
case GCodeProcessor::EMoveType::Color_change: { m_buffers[i].shader = "colorchanges"; break; }
case GCodeProcessor::EMoveType::Pause_Print: { m_buffers[i].shader = "pauses"; break; }
case GCodeProcessor::EMoveType::Custom_GCode: { m_buffers[i].shader = "customs"; break; }
case GCodeProcessor::EMoveType::Retract: { m_buffers[i].shader = "retractions"; break; }
case GCodeProcessor::EMoveType::Unretract: { m_buffers[i].shader = "unretractions"; break; }
case GCodeProcessor::EMoveType::Tool_change: { m_buffers[i].shader = wxGetApp().is_glsl_version_greater_or_equal_to(1, 20) ? "options_120" : "options_110"; break; }
case GCodeProcessor::EMoveType::Color_change: { m_buffers[i].shader = wxGetApp().is_glsl_version_greater_or_equal_to(1, 20) ? "options_120" : "options_110"; break; }
case GCodeProcessor::EMoveType::Pause_Print: { m_buffers[i].shader = wxGetApp().is_glsl_version_greater_or_equal_to(1, 20) ? "options_120" : "options_110"; break; }
case GCodeProcessor::EMoveType::Custom_GCode: { m_buffers[i].shader = wxGetApp().is_glsl_version_greater_or_equal_to(1, 20) ? "options_120" : "options_110"; break; }
case GCodeProcessor::EMoveType::Retract: { m_buffers[i].shader = wxGetApp().is_glsl_version_greater_or_equal_to(1, 20) ? "options_120" : "options_110"; break; }
case GCodeProcessor::EMoveType::Unretract: { m_buffers[i].shader = wxGetApp().is_glsl_version_greater_or_equal_to(1, 20) ? "options_120" : "options_110"; break; }
case GCodeProcessor::EMoveType::Extrude: { m_buffers[i].shader = "extrusions"; break; }
case GCodeProcessor::EMoveType::Travel: { m_buffers[i].shader = "travels"; break; }
default: { break; }
@ -827,6 +827,12 @@ void GCodeViewer::render_toolpaths() const
};
#endif // !ENABLE_SHADERS_MANAGER
bool is_glsl_120 = wxGetApp().is_glsl_version_greater_or_equal_to(1, 20);
int detected_point_sizes[2];
::glGetIntegerv(GL_ALIASED_POINT_SIZE_RANGE, detected_point_sizes);
std::array<float, 2> point_sizes = { 2.0f, std::min(64.0f, static_cast<float>(detected_point_sizes[1])) };
double zoom = wxGetApp().plater()->get_camera().get_zoom();
glsafe(::glCullFace(GL_BACK));
glsafe(::glLineWidth(3.0f));
@ -868,94 +874,139 @@ void GCodeViewer::render_toolpaths() const
{
#if ENABLE_SHADERS_MANAGER
shader->set_uniform("uniform_color", Options_Colors[static_cast<unsigned int>(EOptionsColors::ToolChanges)]);
shader->set_uniform("zoom", zoom);
shader->set_uniform("point_sizes", point_sizes);
if (is_glsl_120)
{
glsafe(::glEnable(GL_POINT_SPRITE));
glsafe(::glEnable(GL_VERTEX_PROGRAM_POINT_SIZE));
}
#else
set_color(static_cast<GLint>(buffer.shader.get_shader_program_id()), Options_Colors[static_cast<unsigned int>(EOptionsColors::ToolChanges)]);
#endif // ENABLE_SHADERS_MANAGER
for (const RenderPath& path : buffer.render_paths)
{
glsafe(::glEnable(GL_PROGRAM_POINT_SIZE));
glsafe(::glMultiDrawElements(GL_POINTS, (const GLsizei*)path.sizes.data(), GL_UNSIGNED_INT, (const void* const*)path.offsets.data(), (GLsizei)path.sizes.size()));
glsafe(::glDisable(GL_PROGRAM_POINT_SIZE));
#if ENABLE_GCODE_VIEWER_STATISTICS
++m_statistics.gl_multi_points_calls_count;
#endif // ENABLE_GCODE_VIEWER_STATISTICS
}
if (is_glsl_120)
{
glsafe(::glDisable(GL_VERTEX_PROGRAM_POINT_SIZE));
glsafe(::glDisable(GL_POINT_SPRITE));
}
break;
}
case GCodeProcessor::EMoveType::Color_change:
{
#if ENABLE_SHADERS_MANAGER
shader->set_uniform("uniform_color", Options_Colors[static_cast<unsigned int>(EOptionsColors::ColorChanges)]);
shader->set_uniform("zoom", zoom);
shader->set_uniform("point_sizes", point_sizes);
if (is_glsl_120)
{
glsafe(::glEnable(GL_POINT_SPRITE));
glsafe(::glEnable(GL_VERTEX_PROGRAM_POINT_SIZE));
}
#else
set_color(static_cast<GLint>(buffer.shader.get_shader_program_id()), Options_Colors[static_cast<unsigned int>(EOptionsColors::ColorChanges)]);
#endif // ENABLE_SHADERS_MANAGER
for (const RenderPath& path : buffer.render_paths)
{
glsafe(::glEnable(GL_PROGRAM_POINT_SIZE));
glsafe(::glMultiDrawElements(GL_POINTS, (const GLsizei*)path.sizes.data(), GL_UNSIGNED_INT, (const void* const*)path.offsets.data(), (GLsizei)path.sizes.size()));
glsafe(::glDisable(GL_PROGRAM_POINT_SIZE));
#if ENABLE_GCODE_VIEWER_STATISTICS
++m_statistics.gl_multi_points_calls_count;
#endif // ENABLE_GCODE_VIEWER_STATISTICS
}
if (is_glsl_120)
{
glsafe(::glDisable(GL_VERTEX_PROGRAM_POINT_SIZE));
glsafe(::glDisable(GL_POINT_SPRITE));
}
break;
}
case GCodeProcessor::EMoveType::Pause_Print:
{
#if ENABLE_SHADERS_MANAGER
shader->set_uniform("uniform_color", Options_Colors[static_cast<unsigned int>(EOptionsColors::PausePrints)]);
shader->set_uniform("zoom", zoom);
shader->set_uniform("point_sizes", point_sizes);
if (is_glsl_120)
{
glsafe(::glEnable(GL_POINT_SPRITE));
glsafe(::glEnable(GL_VERTEX_PROGRAM_POINT_SIZE));
}
#else
set_color(static_cast<GLint>(buffer.shader.get_shader_program_id()), Options_Colors[static_cast<unsigned int>(EOptionsColors::PausePrints)]);
#endif // ENABLE_SHADERS_MANAGER
for (const RenderPath& path : buffer.render_paths)
{
glsafe(::glEnable(GL_PROGRAM_POINT_SIZE));
glsafe(::glMultiDrawElements(GL_POINTS, (const GLsizei*)path.sizes.data(), GL_UNSIGNED_INT, (const void* const*)path.offsets.data(), (GLsizei)path.sizes.size()));
glsafe(::glDisable(GL_PROGRAM_POINT_SIZE));
#if ENABLE_GCODE_VIEWER_STATISTICS
++m_statistics.gl_multi_points_calls_count;
#endif // ENABLE_GCODE_VIEWER_STATISTICS
}
if (is_glsl_120)
{
glsafe(::glDisable(GL_VERTEX_PROGRAM_POINT_SIZE));
glsafe(::glDisable(GL_POINT_SPRITE));
}
break;
}
case GCodeProcessor::EMoveType::Custom_GCode:
{
#if ENABLE_SHADERS_MANAGER
shader->set_uniform("uniform_color", Options_Colors[static_cast<unsigned int>(EOptionsColors::CustomGCodes)]);
shader->set_uniform("zoom", zoom);
shader->set_uniform("point_sizes", point_sizes);
if (is_glsl_120)
{
glsafe(::glEnable(GL_POINT_SPRITE));
glsafe(::glEnable(GL_VERTEX_PROGRAM_POINT_SIZE));
}
#else
set_color(static_cast<GLint>(buffer.shader.get_shader_program_id()), Options_Colors[static_cast<unsigned int>(EOptionsColors::CustomGCodes)]);
#endif // ENABLE_SHADERS_MANAGER
for (const RenderPath& path : buffer.render_paths)
{
glsafe(::glEnable(GL_PROGRAM_POINT_SIZE));
glsafe(::glMultiDrawElements(GL_POINTS, (const GLsizei*)path.sizes.data(), GL_UNSIGNED_INT, (const void* const*)path.offsets.data(), (GLsizei)path.sizes.size()));
glsafe(::glDisable(GL_PROGRAM_POINT_SIZE));
#if ENABLE_GCODE_VIEWER_STATISTICS
++m_statistics.gl_multi_points_calls_count;
#endif // ENABLE_GCODE_VIEWER_STATISTICS
}
if (is_glsl_120)
{
glsafe(::glDisable(GL_VERTEX_PROGRAM_POINT_SIZE));
glsafe(::glDisable(GL_POINT_SPRITE));
}
break;
}
case GCodeProcessor::EMoveType::Retract:
{
#if ENABLE_SHADERS_MANAGER
shader->set_uniform("uniform_color", Options_Colors[static_cast<unsigned int>(EOptionsColors::Retractions)]);
shader->set_uniform("zoom", zoom);
shader->set_uniform("point_sizes", point_sizes);
if (is_glsl_120)
{
glsafe(::glEnable(GL_POINT_SPRITE));
glsafe(::glEnable(GL_VERTEX_PROGRAM_POINT_SIZE));
}
#else
set_color(static_cast<GLint>(buffer.shader.get_shader_program_id()), Options_Colors[static_cast<unsigned int>(EOptionsColors::Retractions)]);
#endif // ENABLE_SHADERS_MANAGER
for (const RenderPath& path : buffer.render_paths)
{
glsafe(::glEnable(GL_PROGRAM_POINT_SIZE));
glsafe(::glMultiDrawElements(GL_POINTS, (const GLsizei*)path.sizes.data(), GL_UNSIGNED_INT, (const void* const*)path.offsets.data(), (GLsizei)path.sizes.size()));
glsafe(::glDisable(GL_PROGRAM_POINT_SIZE));
#if ENABLE_GCODE_VIEWER_STATISTICS
++m_statistics.gl_multi_points_calls_count;
#endif // ENABLE_GCODE_VIEWER_STATISTICS
if (is_glsl_120)
{
glsafe(::glDisable(GL_VERTEX_PROGRAM_POINT_SIZE));
glsafe(::glDisable(GL_POINT_SPRITE));
}
}
break;
}
@ -963,19 +1014,28 @@ void GCodeViewer::render_toolpaths() const
{
#if ENABLE_SHADERS_MANAGER
shader->set_uniform("uniform_color", Options_Colors[static_cast<unsigned int>(EOptionsColors::Unretractions)]);
shader->set_uniform("zoom", zoom);
shader->set_uniform("point_sizes", point_sizes);
if (is_glsl_120)
{
glsafe(::glEnable(GL_POINT_SPRITE));
glsafe(::glEnable(GL_VERTEX_PROGRAM_POINT_SIZE));
}
#else
set_color(static_cast<GLint>(buffer.shader.get_shader_program_id()), Options_Colors[static_cast<unsigned int>(EOptionsColors::Unretractions)]);
#endif // ENABLE_SHADERS_MANAGER
for (const RenderPath& path : buffer.render_paths)
{
glsafe(::glEnable(GL_PROGRAM_POINT_SIZE));
glsafe(::glMultiDrawElements(GL_POINTS, (const GLsizei*)path.sizes.data(), GL_UNSIGNED_INT, (const void* const*)path.offsets.data(), (GLsizei)path.sizes.size()));
glsafe(::glDisable(GL_PROGRAM_POINT_SIZE));
#if ENABLE_GCODE_VIEWER_STATISTICS
++m_statistics.gl_multi_points_calls_count;
#endif // ENABLE_GCODE_VIEWER_STATISTICS
}
if (is_glsl_120)
{
glsafe(::glDisable(GL_VERTEX_PROGRAM_POINT_SIZE));
glsafe(::glDisable(GL_POINT_SPRITE));
}
break;
}
case GCodeProcessor::EMoveType::Extrude:

15
src/slic3r/GUI/GLShadersManager.cpp
View File

@ -34,18 +34,9 @@ std::pair<bool, std::string> GLShadersManager::init()
valid &= append_shader("gouraud_light", { "gouraud_light.vs", "gouraud_light.fs" });
// used to render printbed
valid &= append_shader("printbed", { "printbed.vs", "printbed.fs" });
// used to render tool changes in gcode preview
valid &= append_shader("toolchanges", { "toolchanges.vs", "toolchanges.fs" });
// used to render color changes in gcode preview
valid &= append_shader("colorchanges", { "colorchanges.vs", "colorchanges.fs" });
// used to render pause prints in gcode preview
valid &= append_shader("pauses", { "pauses.vs", "pauses.fs" });
// used to render custom gcode points in gcode preview
valid &= append_shader("customs", { "customs.vs", "customs.fs" });
// used to render retractions in gcode preview
valid &= append_shader("retractions", { "retractions.vs", "retractions.fs" });
// used to render unretractions in gcode preview
valid &= append_shader("unretractions", { "unretractions.vs", "unretractions.fs" });
// used to render options in gcode preview
valid &= append_shader("options_110", { "options_110.vs", "options_110.fs" });
valid &= append_shader("options_120", { "options_120.vs", "options_120.fs" });
// used to render extrusion paths in gcode preview
valid &= append_shader("extrusions", { "extrusions.vs", "extrusions.fs" });
// used to render travel paths in gcode preview