From ac7c4b342bd82c1bf996a3deb9593719fdd2e805 Mon Sep 17 00:00:00 2001 From: enricoturri1966 Date: Thu, 21 Jul 2022 10:18:18 +0200 Subject: [PATCH] Added shaders for OpenGL ES --- resources/shaders/ES/background.fs | 13 +++ resources/shaders/ES/background.vs | 12 +++ resources/shaders/ES/dashed_lines.fs | 20 +++++ resources/shaders/ES/dashed_lines.vs | 17 ++++ resources/shaders/ES/flat.fs | 10 +++ resources/shaders/ES/flat.vs | 11 +++ resources/shaders/ES/flat_clip.fs | 17 ++++ resources/shaders/ES/flat_clip.vs | 23 ++++++ resources/shaders/ES/flat_texture.fs | 12 +++ resources/shaders/ES/flat_texture.vs | 15 ++++ resources/shaders/ES/gouraud.fs | 81 +++++++++++++++++++ resources/shaders/ES/gouraud.vs | 77 ++++++++++++++++++ resources/shaders/ES/gouraud_light.fs | 14 ++++ resources/shaders/ES/gouraud_light.vs | 45 +++++++++++ .../shaders/ES/gouraud_light_instanced.fs | 12 +++ .../shaders/ES/gouraud_light_instanced.vs | 50 ++++++++++++ resources/shaders/ES/imgui.fs | 13 +++ resources/shaders/ES/imgui.vs | 17 ++++ resources/shaders/ES/mm_contour.fs | 10 +++ resources/shaders/ES/mm_contour.vs | 15 ++++ resources/shaders/ES/mm_gouraud.fs | 66 +++++++++++++++ resources/shaders/ES/mm_gouraud.vs | 28 +++++++ resources/shaders/ES/printbed.fs | 38 +++++++++ resources/shaders/ES/printbed.vs | 15 ++++ resources/shaders/ES/toolpaths_cog.fs | 21 +++++ resources/shaders/ES/toolpaths_cog.vs | 47 +++++++++++ resources/shaders/ES/variable_layer_height.fs | 44 ++++++++++ resources/shaders/ES/variable_layer_height.vs | 60 ++++++++++++++ resources/shaders/ES/wireframe.fs | 19 +++++ resources/shaders/ES/wireframe.vs | 20 +++++ 30 files changed, 842 insertions(+) create mode 100644 resources/shaders/ES/background.fs create mode 100644 resources/shaders/ES/background.vs create mode 100644 resources/shaders/ES/dashed_lines.fs create mode 100644 resources/shaders/ES/dashed_lines.vs create mode 100644 resources/shaders/ES/flat.fs create mode 100644 resources/shaders/ES/flat.vs create mode 100644 resources/shaders/ES/flat_clip.fs create mode 100644 resources/shaders/ES/flat_clip.vs create mode 100644 resources/shaders/ES/flat_texture.fs create mode 100644 resources/shaders/ES/flat_texture.vs create mode 100644 resources/shaders/ES/gouraud.fs create mode 100644 resources/shaders/ES/gouraud.vs create mode 100644 resources/shaders/ES/gouraud_light.fs create mode 100644 resources/shaders/ES/gouraud_light.vs create mode 100644 resources/shaders/ES/gouraud_light_instanced.fs create mode 100644 resources/shaders/ES/gouraud_light_instanced.vs create mode 100644 resources/shaders/ES/imgui.fs create mode 100644 resources/shaders/ES/imgui.vs create mode 100644 resources/shaders/ES/mm_contour.fs create mode 100644 resources/shaders/ES/mm_contour.vs create mode 100644 resources/shaders/ES/mm_gouraud.fs create mode 100644 resources/shaders/ES/mm_gouraud.vs create mode 100644 resources/shaders/ES/printbed.fs create mode 100644 resources/shaders/ES/printbed.vs create mode 100644 resources/shaders/ES/toolpaths_cog.fs create mode 100644 resources/shaders/ES/toolpaths_cog.vs create mode 100644 resources/shaders/ES/variable_layer_height.fs create mode 100644 resources/shaders/ES/variable_layer_height.vs create mode 100644 resources/shaders/ES/wireframe.fs create mode 100644 resources/shaders/ES/wireframe.vs diff --git a/resources/shaders/ES/background.fs b/resources/shaders/ES/background.fs new file mode 100644 index 000000000..5f46e658f --- /dev/null +++ b/resources/shaders/ES/background.fs @@ -0,0 +1,13 @@ +#version 100 + +precision highp float; + +uniform vec4 top_color; +uniform vec4 bottom_color; + +varying vec2 tex_coord; + +void main() +{ + gl_FragColor = mix(bottom_color, top_color, tex_coord.y); +} diff --git a/resources/shaders/ES/background.vs b/resources/shaders/ES/background.vs new file mode 100644 index 000000000..6334c83b1 --- /dev/null +++ b/resources/shaders/ES/background.vs @@ -0,0 +1,12 @@ +#version 100 + +attribute vec3 v_position; +attribute vec2 v_tex_coord; + +varying vec2 tex_coord; + +void main() +{ + tex_coord = v_tex_coord; + gl_Position = vec4(v_position, 1.0); +} diff --git a/resources/shaders/ES/dashed_lines.fs b/resources/shaders/ES/dashed_lines.fs new file mode 100644 index 000000000..9aecd0240 --- /dev/null +++ b/resources/shaders/ES/dashed_lines.fs @@ -0,0 +1,20 @@ +#version 100 + +precision highp float; + +// see as reference: https://stackoverflow.com/questions/52928678/dashed-line-in-opengl3 + +uniform float dash_size; +uniform float gap_size; +uniform vec4 uniform_color; + +varying float coord_s; + +void main() +{ + float inv_stride = 1.0 / (dash_size + gap_size); + if (gap_size > 0.0 && fract(coord_s * inv_stride) > dash_size * inv_stride) + discard; + + gl_FragColor = uniform_color; +} diff --git a/resources/shaders/ES/dashed_lines.vs b/resources/shaders/ES/dashed_lines.vs new file mode 100644 index 000000000..540715a11 --- /dev/null +++ b/resources/shaders/ES/dashed_lines.vs @@ -0,0 +1,17 @@ +#version 100 + +// see as reference: https://stackoverflow.com/questions/52928678/dashed-line-in-opengl3 + +uniform mat4 view_model_matrix; +uniform mat4 projection_matrix; + +// v_position.w = coordinate along the line +attribute vec4 v_position; + +varying float coord_s; + +void main() +{ + coord_s = v_position.w; + gl_Position = projection_matrix * view_model_matrix * vec4(v_position.xyz, 1.0); +} \ No newline at end of file diff --git a/resources/shaders/ES/flat.fs b/resources/shaders/ES/flat.fs new file mode 100644 index 000000000..f27e5d38c --- /dev/null +++ b/resources/shaders/ES/flat.fs @@ -0,0 +1,10 @@ +#version 100 + +precision highp float; + +uniform vec4 uniform_color; + +void main() +{ + gl_FragColor = uniform_color; +} diff --git a/resources/shaders/ES/flat.vs b/resources/shaders/ES/flat.vs new file mode 100644 index 000000000..a83587239 --- /dev/null +++ b/resources/shaders/ES/flat.vs @@ -0,0 +1,11 @@ +#version 100 + +uniform mat4 view_model_matrix; +uniform mat4 projection_matrix; + +attribute vec3 v_position; + +void main() +{ + gl_Position = projection_matrix * view_model_matrix * vec4(v_position, 1.0); +} diff --git a/resources/shaders/ES/flat_clip.fs b/resources/shaders/ES/flat_clip.fs new file mode 100644 index 000000000..8de7d1921 --- /dev/null +++ b/resources/shaders/ES/flat_clip.fs @@ -0,0 +1,17 @@ +#version 100 + +precision highp float; + +const vec3 ZERO = vec3(0.0, 0.0, 0.0); + +uniform vec4 uniform_color; + +varying vec3 clipping_planes_dots; + +void main() +{ + if (any(lessThan(clipping_planes_dots, ZERO))) + discard; + + gl_FragColor = uniform_color; +} diff --git a/resources/shaders/ES/flat_clip.vs b/resources/shaders/ES/flat_clip.vs new file mode 100644 index 000000000..baf5a3385 --- /dev/null +++ b/resources/shaders/ES/flat_clip.vs @@ -0,0 +1,23 @@ +#version 100 + +uniform mat4 view_model_matrix; +uniform mat4 projection_matrix; +uniform mat4 volume_world_matrix; + +// Clipping plane, x = min z, y = max z. Used by the FFF and SLA previews to clip with a top / bottom plane. +uniform vec2 z_range; +// Clipping plane - general orientation. Used by the SLA gizmo. +uniform vec4 clipping_plane; + +attribute vec3 v_position; + +varying vec3 clipping_planes_dots; + +void main() +{ + // Fill in the scalars for fragment shader clipping. Fragments with any of these components lower than zero are discarded. + vec4 world_pos = volume_world_matrix * vec4(v_position, 1.0); + clipping_planes_dots = vec3(dot(world_pos, clipping_plane), world_pos.z - z_range.x, z_range.y - world_pos.z); + + gl_Position = projection_matrix * view_model_matrix * vec4(v_position, 1.0); +} diff --git a/resources/shaders/ES/flat_texture.fs b/resources/shaders/ES/flat_texture.fs new file mode 100644 index 000000000..ec41960f7 --- /dev/null +++ b/resources/shaders/ES/flat_texture.fs @@ -0,0 +1,12 @@ +#version 100 + +precision highp float; + +uniform sampler2D uniform_texture; + +varying vec2 tex_coord; + +void main() +{ + gl_FragColor = texture2D(uniform_texture, tex_coord); +} diff --git a/resources/shaders/ES/flat_texture.vs b/resources/shaders/ES/flat_texture.vs new file mode 100644 index 000000000..e83cacd59 --- /dev/null +++ b/resources/shaders/ES/flat_texture.vs @@ -0,0 +1,15 @@ +#version 100 + +uniform mat4 view_model_matrix; +uniform mat4 projection_matrix; + +attribute vec3 v_position; +attribute vec2 v_tex_coord; + +varying vec2 tex_coord; + +void main() +{ + tex_coord = v_tex_coord; + gl_Position = projection_matrix * view_model_matrix * vec4(v_position, 1.0); +} diff --git a/resources/shaders/ES/gouraud.fs b/resources/shaders/ES/gouraud.fs new file mode 100644 index 000000000..368a50279 --- /dev/null +++ b/resources/shaders/ES/gouraud.fs @@ -0,0 +1,81 @@ +#version 100 + +precision highp float; + +const vec3 ZERO = vec3(0.0, 0.0, 0.0); +const float EPSILON = 0.0001; + +struct PrintVolumeDetection +{ + // 0 = rectangle, 1 = circle, 2 = custom, 3 = invalid + int type; + // type = 0 (rectangle): + // x = min.x, y = min.y, z = max.x, w = max.y + // type = 1 (circle): + // x = center.x, y = center.y, z = radius + vec4 xy_data; + // x = min z, y = max z + vec2 z_data; +}; + +struct SlopeDetection +{ + bool actived; + float normal_z; + mat3 volume_world_normal_matrix; +}; + +uniform vec4 uniform_color; +uniform SlopeDetection slope; + +#ifdef ENABLE_ENVIRONMENT_MAP + uniform sampler2D environment_tex; + uniform bool use_environment_tex; +#endif // ENABLE_ENVIRONMENT_MAP + +uniform PrintVolumeDetection print_volume; + +varying vec3 clipping_planes_dots; + +// x = diffuse, y = specular; +varying vec2 intensity; + +varying vec4 world_pos; +varying float world_normal_z; +varying vec3 eye_normal; + +void main() +{ + if (any(lessThan(clipping_planes_dots, ZERO))) + discard; + vec3 color = uniform_color.rgb; + float alpha = uniform_color.a; + + if (slope.actived && world_normal_z < slope.normal_z - EPSILON) { + color = vec3(0.7, 0.7, 1.0); + alpha = 1.0; + } + + // if the fragment is outside the print volume -> use darker color + vec3 pv_check_min = ZERO; + vec3 pv_check_max = ZERO; + if (print_volume.type == 0) { + // rectangle + pv_check_min = world_pos.xyz - vec3(print_volume.xy_data.x, print_volume.xy_data.y, print_volume.z_data.x); + pv_check_max = world_pos.xyz - vec3(print_volume.xy_data.z, print_volume.xy_data.w, print_volume.z_data.y); + } + else if (print_volume.type == 1) { + // circle + float delta_radius = print_volume.xy_data.z - distance(world_pos.xy, print_volume.xy_data.xy); + pv_check_min = vec3(delta_radius, 0.0, world_pos.z - print_volume.z_data.x); + pv_check_max = vec3(0.0, 0.0, world_pos.z - print_volume.z_data.y); + } + color = (any(lessThan(pv_check_min, ZERO)) || any(greaterThan(pv_check_max, ZERO))) ? mix(color, ZERO, 0.3333) : color; + +#ifdef ENABLE_ENVIRONMENT_MAP + if (use_environment_tex) + gl_FragColor = vec4(0.45 * texture2D(environment_tex, normalize(eye_normal).xy * 0.5 + 0.5).xyz + 0.8 * color * intensity.x, alpha); + else +#endif + gl_FragColor = vec4(vec3(intensity.y) + color * intensity.x, alpha); +} diff --git a/resources/shaders/ES/gouraud.vs b/resources/shaders/ES/gouraud.vs new file mode 100644 index 000000000..431e48556 --- /dev/null +++ b/resources/shaders/ES/gouraud.vs @@ -0,0 +1,77 @@ +#version 100 + +#define INTENSITY_CORRECTION 0.6 + +// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31) +const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929); +#define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION) +#define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION) +#define LIGHT_TOP_SHININESS 20.0 + +// normalized values for (1./1.43, 0.2/1.43, 1./1.43) +const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074); +#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION) +//#define LIGHT_FRONT_SPECULAR (0.0 * INTENSITY_CORRECTION) +//#define LIGHT_FRONT_SHININESS 5.0 + +#define INTENSITY_AMBIENT 0.3 + +const vec3 ZERO = vec3(0.0, 0.0, 0.0); + +struct SlopeDetection +{ + bool actived; + float normal_z; + mat3 volume_world_normal_matrix; +}; + +uniform mat4 view_model_matrix; +uniform mat4 projection_matrix; +uniform mat3 view_normal_matrix; +uniform mat4 volume_world_matrix; +uniform SlopeDetection slope; + +// Clipping plane, x = min z, y = max z. Used by the FFF and SLA previews to clip with a top / bottom plane. +uniform vec2 z_range; +// Clipping plane - general orientation. Used by the SLA gizmo. +uniform vec4 clipping_plane; + +attribute vec3 v_position; +attribute vec3 v_normal; + +// x = diffuse, y = specular; +varying vec2 intensity; + +varying vec3 clipping_planes_dots; + +varying vec4 world_pos; +varying float world_normal_z; +varying vec3 eye_normal; + +void main() +{ + // First transform the normal into camera space and normalize the result. + 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. + float NdotL = max(dot(eye_normal, LIGHT_TOP_DIR), 0.0); + + intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE; + vec4 position = view_model_matrix * vec4(v_position, 1.0); + intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(position.xyz), reflect(-LIGHT_TOP_DIR, eye_normal)), 0.0), LIGHT_TOP_SHININESS); + + // Perform the same lighting calculation for the 2nd light source (no specular applied). + NdotL = max(dot(eye_normal, LIGHT_FRONT_DIR), 0.0); + intensity.x += NdotL * LIGHT_FRONT_DIFFUSE; + + // Point in homogenous coordinates. + world_pos = volume_world_matrix * vec4(v_position, 1.0); + + // z component of normal vector in world coordinate used for slope shading + world_normal_z = slope.actived ? (normalize(slope.volume_world_normal_matrix * v_normal)).z : 0.0; + + gl_Position = projection_matrix * position; + // Fill in the scalars for fragment shader clipping. Fragments with any of these components lower than zero are discarded. + clipping_planes_dots = vec3(dot(world_pos, clipping_plane), world_pos.z - z_range.x, z_range.y - world_pos.z); +} diff --git a/resources/shaders/ES/gouraud_light.fs b/resources/shaders/ES/gouraud_light.fs new file mode 100644 index 000000000..a8de5879c --- /dev/null +++ b/resources/shaders/ES/gouraud_light.fs @@ -0,0 +1,14 @@ +#version 100 + +precision highp float; + +uniform vec4 uniform_color; +uniform float emission_factor; + +// x = tainted, y = specular; +varying vec2 intensity; + +void main() +{ + gl_FragColor = vec4(vec3(intensity.y) + uniform_color.rgb * (intensity.x + emission_factor), uniform_color.a); +} diff --git a/resources/shaders/ES/gouraud_light.vs b/resources/shaders/ES/gouraud_light.vs new file mode 100644 index 000000000..98bde435d --- /dev/null +++ b/resources/shaders/ES/gouraud_light.vs @@ -0,0 +1,45 @@ +#version 100 + +#define INTENSITY_CORRECTION 0.6 + +// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31) +const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929); +#define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION) +#define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION) +#define LIGHT_TOP_SHININESS 20.0 + +// normalized values for (1./1.43, 0.2/1.43, 1./1.43) +const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074); +#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION) + +#define INTENSITY_AMBIENT 0.3 + +uniform mat4 view_model_matrix; +uniform mat4 projection_matrix; +uniform mat3 view_normal_matrix; + +attribute vec3 v_position; +attribute vec3 v_normal; + +// x = tainted, y = specular; +varying vec2 intensity; + +void main() +{ + // First transform the normal into camera space and normalize the result. + 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. + float NdotL = max(dot(normal, LIGHT_TOP_DIR), 0.0); + + intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE; + vec4 position = view_model_matrix * vec4(v_position, 1.0); + intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(position.xyz), 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; + + gl_Position = projection_matrix * position; +} diff --git a/resources/shaders/ES/gouraud_light_instanced.fs b/resources/shaders/ES/gouraud_light_instanced.fs new file mode 100644 index 000000000..d737137ee --- /dev/null +++ b/resources/shaders/ES/gouraud_light_instanced.fs @@ -0,0 +1,12 @@ +#version 100 + +uniform vec4 uniform_color; +uniform float emission_factor; + +// x = tainted, y = specular; +varying vec2 intensity; + +void main() +{ + gl_FragColor = vec4(vec3(intensity.y) + uniform_color.rgb * (intensity.x + emission_factor), uniform_color.a); +} diff --git a/resources/shaders/ES/gouraud_light_instanced.vs b/resources/shaders/ES/gouraud_light_instanced.vs new file mode 100644 index 000000000..0aebd7a0b --- /dev/null +++ b/resources/shaders/ES/gouraud_light_instanced.vs @@ -0,0 +1,50 @@ +#version 100 + +#define INTENSITY_CORRECTION 0.6 + +// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31) +const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929); +#define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION) +#define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION) +#define LIGHT_TOP_SHININESS 20.0 + +// normalized values for (1./1.43, 0.2/1.43, 1./1.43) +const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074); +#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION) + +#define INTENSITY_AMBIENT 0.3 + +uniform mat4 view_model_matrix; +uniform mat4 projection_matrix; +uniform mat3 view_normal_matrix; + +// vertex attributes +attribute vec3 v_position; +attribute vec3 v_normal; +// instance attributes +attribute vec3 i_offset; +attribute vec2 i_scales; + +// x = tainted, y = specular; +varying vec2 intensity; + +void main() +{ + // First transform the normal into camera space and normalize the result. + vec3 eye_normal = normalize(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. + float NdotL = max(dot(eye_normal, LIGHT_TOP_DIR), 0.0); + + intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE; + vec4 world_position = vec4(v_position * vec3(vec2(1.5 * i_scales.x), 1.5 * i_scales.y) + i_offset - vec3(0.0, 0.0, 0.5 * i_scales.y), 1.0); + vec4 eye_position = view_model_matrix * world_position; + intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(eye_position.xyz), reflect(-LIGHT_TOP_DIR, eye_normal)), 0.0), LIGHT_TOP_SHININESS); + + // Perform the same lighting calculation for the 2nd light source (no specular applied). + NdotL = max(dot(eye_normal, LIGHT_FRONT_DIR), 0.0); + intensity.x += NdotL * LIGHT_FRONT_DIFFUSE; + + gl_Position = projection_matrix * eye_position; +} diff --git a/resources/shaders/ES/imgui.fs b/resources/shaders/ES/imgui.fs new file mode 100644 index 000000000..2174f955d --- /dev/null +++ b/resources/shaders/ES/imgui.fs @@ -0,0 +1,13 @@ +#version 100 + +precision highp float; + +uniform sampler2D Texture; + +varying vec2 Frag_UV; +varying vec4 Frag_Color; + +void main() +{ + gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st); +} \ No newline at end of file diff --git a/resources/shaders/ES/imgui.vs b/resources/shaders/ES/imgui.vs new file mode 100644 index 000000000..7abb3f405 --- /dev/null +++ b/resources/shaders/ES/imgui.vs @@ -0,0 +1,17 @@ +#version 100 + +uniform mat4 ProjMtx; + +attribute vec2 Position; +attribute vec2 UV; +attribute vec4 Color; + +varying vec2 Frag_UV; +varying vec4 Frag_Color; + +void main() +{ + Frag_UV = UV; + Frag_Color = Color; + gl_Position = ProjMtx * vec4(Position.xy, 0.0, 1.0); +} \ No newline at end of file diff --git a/resources/shaders/ES/mm_contour.fs b/resources/shaders/ES/mm_contour.fs new file mode 100644 index 000000000..f27e5d38c --- /dev/null +++ b/resources/shaders/ES/mm_contour.fs @@ -0,0 +1,10 @@ +#version 100 + +precision highp float; + +uniform vec4 uniform_color; + +void main() +{ + gl_FragColor = uniform_color; +} diff --git a/resources/shaders/ES/mm_contour.vs b/resources/shaders/ES/mm_contour.vs new file mode 100644 index 000000000..7142a5de6 --- /dev/null +++ b/resources/shaders/ES/mm_contour.vs @@ -0,0 +1,15 @@ +#version 100 + +uniform mat4 view_model_matrix; +uniform mat4 projection_matrix; +uniform float offset; + +attribute vec3 v_position; + +void main() +{ + // Add small epsilon to z to solve z-fighting + vec4 clip_position = projection_matrix * view_model_matrix * vec4(v_position, 1.0); + clip_position.z -= offset * abs(clip_position.w); + gl_Position = clip_position; +} diff --git a/resources/shaders/ES/mm_gouraud.fs b/resources/shaders/ES/mm_gouraud.fs new file mode 100644 index 000000000..4824753f1 --- /dev/null +++ b/resources/shaders/ES/mm_gouraud.fs @@ -0,0 +1,66 @@ +#version 100 +#extension GL_OES_standard_derivatives : enable + +precision highp float; + +#define INTENSITY_CORRECTION 0.6 + +// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31) +const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929); +#define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION) +#define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION) +#define LIGHT_TOP_SHININESS 20.0 + +// normalized values for (1./1.43, 0.2/1.43, 1./1.43) +const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074); +#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION) + +#define INTENSITY_AMBIENT 0.3 + +const vec3 ZERO = vec3(0.0, 0.0, 0.0); +const float EPSILON = 0.0001; + +uniform vec4 uniform_color; + +uniform bool volume_mirrored; + +uniform mat4 view_model_matrix; +uniform mat3 view_normal_matrix; + +varying vec3 clipping_planes_dots; +varying vec4 model_pos; + +void main() +{ + if (any(lessThan(clipping_planes_dots, ZERO))) + discard; + vec3 color = uniform_color.rgb; + float alpha = uniform_color.a; + + vec3 triangle_normal = normalize(cross(dFdx(model_pos.xyz), dFdy(model_pos.xyz))); +#ifdef FLIP_TRIANGLE_NORMALS + triangle_normal = -triangle_normal; +#endif + + if (volume_mirrored) + triangle_normal = -triangle_normal; + + // First transform the normal into camera space and normalize the result. + 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. + float NdotL = max(dot(eye_normal, LIGHT_TOP_DIR), 0.0); + + // x = diffuse, y = specular; + vec2 intensity = vec2(0.0); + intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE; + vec3 position = (view_model_matrix * model_pos).xyz; + intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(position), reflect(-LIGHT_TOP_DIR, eye_normal)), 0.0), LIGHT_TOP_SHININESS); + + // Perform the same lighting calculation for the 2nd light source (no specular applied). + NdotL = max(dot(eye_normal, LIGHT_FRONT_DIR), 0.0); + intensity.x += NdotL * LIGHT_FRONT_DIFFUSE; + + gl_FragColor = vec4(vec3(intensity.y) + color * intensity.x, alpha); +} diff --git a/resources/shaders/ES/mm_gouraud.vs b/resources/shaders/ES/mm_gouraud.vs new file mode 100644 index 000000000..8ad5fca68 --- /dev/null +++ b/resources/shaders/ES/mm_gouraud.vs @@ -0,0 +1,28 @@ +#version 100 + +const vec3 ZERO = vec3(0.0, 0.0, 0.0); + +uniform mat4 view_model_matrix; +uniform mat4 projection_matrix; + +uniform mat4 volume_world_matrix; +// Clipping plane, x = min z, y = max z. Used by the FFF and SLA previews to clip with a top / bottom plane. +uniform vec2 z_range; +// Clipping plane - general orientation. Used by the SLA gizmo. +uniform vec4 clipping_plane; + +attribute vec3 v_position; + +varying vec3 clipping_planes_dots; +varying vec4 model_pos; + +void main() +{ + model_pos = vec4(v_position, 1.0); + // Point in homogenous coordinates. + vec4 world_pos = volume_world_matrix * model_pos; + + gl_Position = projection_matrix * view_model_matrix * model_pos; + // Fill in the scalars for fragment shader clipping. Fragments with any of these components lower than zero are discarded. + clipping_planes_dots = vec3(dot(world_pos, clipping_plane), world_pos.z - z_range.x, z_range.y - world_pos.z); +} diff --git a/resources/shaders/ES/printbed.fs b/resources/shaders/ES/printbed.fs new file mode 100644 index 000000000..517536467 --- /dev/null +++ b/resources/shaders/ES/printbed.fs @@ -0,0 +1,38 @@ +#version 100 + +precision highp float; + +const vec3 back_color_dark = vec3(0.235, 0.235, 0.235); +const vec3 back_color_light = vec3(0.365, 0.365, 0.365); + +uniform sampler2D texture; +uniform bool transparent_background; +uniform bool svg_source; + +varying vec2 tex_coord; + +vec4 svg_color() +{ + // takes foreground from texture + vec4 fore_color = texture2D(texture, tex_coord); + + // calculates radial gradient + vec3 back_color = vec3(mix(back_color_light, back_color_dark, smoothstep(0.0, 0.5, length(abs(tex_coord.xy) - vec2(0.5))))); + + // blends foreground with background + return vec4(mix(back_color, fore_color.rgb, fore_color.a), transparent_background ? fore_color.a : 1.0); +} + +vec4 non_svg_color() +{ + // takes foreground from texture + vec4 color = texture2D(texture, tex_coord); + return vec4(color.rgb, transparent_background ? color.a * 0.25 : color.a); +} + +void main() +{ + vec4 color = svg_source ? svg_color() : non_svg_color(); + color.a = transparent_background ? color.a * 0.5 : color.a; + gl_FragColor = color; +} \ No newline at end of file diff --git a/resources/shaders/ES/printbed.vs b/resources/shaders/ES/printbed.vs new file mode 100644 index 000000000..e83cacd59 --- /dev/null +++ b/resources/shaders/ES/printbed.vs @@ -0,0 +1,15 @@ +#version 100 + +uniform mat4 view_model_matrix; +uniform mat4 projection_matrix; + +attribute vec3 v_position; +attribute vec2 v_tex_coord; + +varying vec2 tex_coord; + +void main() +{ + tex_coord = v_tex_coord; + gl_Position = projection_matrix * view_model_matrix * vec4(v_position, 1.0); +} diff --git a/resources/shaders/ES/toolpaths_cog.fs b/resources/shaders/ES/toolpaths_cog.fs new file mode 100644 index 000000000..f5e4404be --- /dev/null +++ b/resources/shaders/ES/toolpaths_cog.fs @@ -0,0 +1,21 @@ +#version 100 + +precision highp float; + +const vec4 BLACK = vec4(vec3(0.1), 1.0); +const vec4 WHITE = vec4(vec3(1.0), 1.0); + +const float emission_factor = 0.25; + +uniform vec3 world_center; + +// x = tainted, y = specular; +varying vec2 intensity; +varying vec3 world_position; + +void main() +{ + vec3 delta = world_position - world_center; + vec4 color = delta.x * delta.y * delta.z > 0.0 ? BLACK : WHITE; + gl_FragColor = vec4(vec3(intensity.y) + color.rgb * (intensity.x + emission_factor), 1.0); +} diff --git a/resources/shaders/ES/toolpaths_cog.vs b/resources/shaders/ES/toolpaths_cog.vs new file mode 100644 index 000000000..72b5835bd --- /dev/null +++ b/resources/shaders/ES/toolpaths_cog.vs @@ -0,0 +1,47 @@ +#version 100 + +#define INTENSITY_CORRECTION 0.6 + +// normalized values for (-0.6/1.31, 0.6/1.31, 1./1.31) +const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929); +#define LIGHT_TOP_DIFFUSE (0.8 * INTENSITY_CORRECTION) +#define LIGHT_TOP_SPECULAR (0.125 * INTENSITY_CORRECTION) +#define LIGHT_TOP_SHININESS 20.0 + +// normalized values for (1./1.43, 0.2/1.43, 1./1.43) +const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074); +#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION) + +#define INTENSITY_AMBIENT 0.3 + +uniform mat4 view_model_matrix; +uniform mat4 projection_matrix; +uniform mat3 view_normal_matrix; + +attribute vec3 v_position; +attribute vec3 v_normal; + +// x = tainted, y = specular; +varying vec2 intensity; +varying vec3 world_position; + +void main() +{ + // First transform the normal into camera space and normalize the result. + 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. + float NdotL = max(dot(normal, LIGHT_TOP_DIR), 0.0); + + intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE; + vec4 position = view_model_matrix * vec4(v_position, 1.0); + intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(position.xyz), 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; + + world_position = v_position; + gl_Position = projection_matrix * position; +} diff --git a/resources/shaders/ES/variable_layer_height.fs b/resources/shaders/ES/variable_layer_height.fs new file mode 100644 index 000000000..ac96f31b7 --- /dev/null +++ b/resources/shaders/ES/variable_layer_height.fs @@ -0,0 +1,44 @@ +#version 100 +#extension GL_OES_standard_derivatives : enable + +precision highp float; + +#define M_PI 3.1415926535897932384626433832795 + +// 2D texture (1D texture split by the rows) of color along the object Z axis. +uniform sampler2D z_texture; +// Scaling from the Z texture rows coordinate to the normalized texture row coordinate. +uniform float z_to_texture_row; +uniform float z_texture_row_to_normalized; +uniform float z_cursor; +uniform float z_cursor_band_width; + +// x = tainted, y = specular; +varying vec2 intensity; + +varying float object_z; + +void main() +{ + float object_z_row = z_to_texture_row * object_z; + // Index of the row in the texture. + float z_texture_row = floor(object_z_row); + // Normalized coordinate from 0. to 1. + float z_texture_col = object_z_row - z_texture_row; + float z_blend = 0.25 * cos(min(M_PI, abs(M_PI * (object_z - z_cursor) * 1.8 / z_cursor_band_width))) + 0.25; + // Calculate level of detail from the object Z coordinate. + // This makes the slowly sloping surfaces to be shown with high detail (with stripes), + // and the vertical surfaces to be shown with low detail (no stripes) + float z_in_cells = object_z_row * 190.; + // Gradient of Z projected on the screen. + float dx_vtc = dFdx(z_in_cells); + float dy_vtc = dFdy(z_in_cells); + float lod = clamp(0.5 * log2(max(dx_vtc * dx_vtc, dy_vtc * dy_vtc)), 0., 1.); + // Sample the Z texture. Texture coordinates are normalized to <0, 1>. + vec4 color = vec4(0.25, 0.25, 0.25, 1.0); + if (z_texture_row >= 0.0) + color = mix(texture2D(z_texture, vec2(z_texture_col, z_texture_row_to_normalized * (z_texture_row + 0.5 )), -10000.), + texture2D(z_texture, vec2(z_texture_col, z_texture_row_to_normalized * (z_texture_row * 2. + 1.)), 10000.), lod); + // Mix the final color. + gl_FragColor = vec4(vec3(intensity.y), 1.0) + intensity.x * mix(color, vec4(1.0, 1.0, 0.0, 1.0), z_blend); +} diff --git a/resources/shaders/ES/variable_layer_height.vs b/resources/shaders/ES/variable_layer_height.vs new file mode 100644 index 000000000..8deaf8368 --- /dev/null +++ b/resources/shaders/ES/variable_layer_height.vs @@ -0,0 +1,60 @@ +#version 100 + +#define INTENSITY_CORRECTION 0.6 + +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 + +const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074); +#define LIGHT_FRONT_DIFFUSE (0.3 * INTENSITY_CORRECTION) +//#define LIGHT_FRONT_SPECULAR (0.0 * INTENSITY_CORRECTION) +//#define LIGHT_FRONT_SHININESS 5.0 + +#define INTENSITY_AMBIENT 0.3 + +uniform mat4 view_model_matrix; +uniform mat4 projection_matrix; +uniform mat3 view_normal_matrix; +uniform mat4 volume_world_matrix; +uniform float object_max_z; + +attribute vec3 v_position; +attribute vec3 v_normal; +attribute vec2 v_tex_coord; + +// x = tainted, y = specular; +varying vec2 intensity; + +varying float object_z; + +void main() +{ + // ===================================================== + // NOTE: + // when object_max_z > 0.0 we are rendering the overlay + // when object_max_z == 0.0 we are rendering the volumes + // ===================================================== + + // 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(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. + float NdotL = max(dot(normal, LIGHT_TOP_DIR), 0.0); + + intensity.x = INTENSITY_AMBIENT + NdotL * LIGHT_TOP_DIFFUSE; + vec4 position = view_model_matrix * vec4(v_position, 1.0); + intensity.y = LIGHT_TOP_SPECULAR * pow(max(dot(-normalize(position.xyz), reflect(-LIGHT_TOP_DIR, normal)), 0.0), LIGHT_TOP_SHININESS); + + // Perform the same lighting calculation for the 2nd light source (no specular) + NdotL = max(dot(normal, LIGHT_FRONT_DIR), 0.0); + + intensity.x += NdotL * LIGHT_FRONT_DIFFUSE; + + // Scaled to widths of the Z texture. + object_z = (object_max_z > 0.0) ? object_max_z * v_tex_coord.y : (volume_world_matrix * vec4(v_position, 1.0)).z; + + gl_Position = projection_matrix * position; +} diff --git a/resources/shaders/ES/wireframe.fs b/resources/shaders/ES/wireframe.fs new file mode 100644 index 000000000..036ee8879 --- /dev/null +++ b/resources/shaders/ES/wireframe.fs @@ -0,0 +1,19 @@ +#version 100 +#extension GL_OES_standard_derivatives : enable + +// see for reference: https://stackoverflow.com/questions/7361582/opengl-debugging-single-pass-wireframe-rendering + +precision highp float; + +uniform vec4 uniform_color; + +varying vec3 barycentric; + +void main() +{ + float min_dist = min(min(barycentric.x, barycentric.y), barycentric.z); + if (min_dist > 0.5 * fwidth(min_dist)) + discard; + + gl_FragColor = uniform_color; +} \ No newline at end of file diff --git a/resources/shaders/ES/wireframe.vs b/resources/shaders/ES/wireframe.vs new file mode 100644 index 000000000..00a5214f5 --- /dev/null +++ b/resources/shaders/ES/wireframe.vs @@ -0,0 +1,20 @@ +#version 100 + +uniform mat4 view_model_matrix; +uniform mat4 projection_matrix; +uniform float offset; + +attribute vec3 v_position; +attribute vec3 v_normal; +attribute vec3 v_extra; + +varying vec3 barycentric; + +void main() +{ + barycentric = v_extra; + // Add small epsilon to z to solve z-fighting + vec4 clip_position = projection_matrix * view_model_matrix * vec4(v_position, 1.0); + clip_position.z -= offset * abs(clip_position.w); + gl_Position = clip_position; +} \ No newline at end of file