Phong Shading

resources/shaders/110/phong.fs

@@ -0,0 +1,190 @@
+#version 110
+
+const vec3 ZERO = vec3(0.0, 0.0, 0.0);
+const vec3 LightRed = vec3(0.78, 0.0, 0.0);
+const vec3 LightBlue = vec3(0.73, 1.0, 1.0);
+const float EPSILON = 0.0001;
+
+#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.85 * INTENSITY_CORRECTION)
+#define LIGHT_TOP_SHININESS  72.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.20 * INTENSITY_CORRECTION)
+#define LIGHT_FRONT_SHININESS 28.0
+#define LIGHT_FRONT_SPECULAR (0.20 * INTENSITY_CORRECTION)
+#define LIGHT_FRONT_SHININESS 28.0
+
+#define INTENSITY_AMBIENT    0.22
+
+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 bool use_color_clip_plane;
+uniform vec4 uniform_color_clip_plane_1;
+uniform vec4 uniform_color_clip_plane_2;
+uniform SlopeDetection slope;
+
+//BBS: add outline_color
+uniform bool is_outline;
+uniform sampler2D depth_tex;
+uniform vec2 screen_size;
+
+#ifdef ENABLE_ENVIRONMENT_MAP
+    uniform sampler2D environment_tex;
+    uniform bool use_environment_tex;
+#endif // ENABLE_ENVIRONMENT_MAP
+
+uniform PrintVolumeDetection print_volume;
+
+uniform float z_far;
+uniform float z_near;
+
+varying vec3 clipping_planes_dots;
+varying float color_clip_plane_dot;
+
+varying vec4 world_pos;
+varying float world_normal_z;
+varying vec3 eye_normal;
+varying vec3 eye_position;
+
+vec3 getBackfaceColor(vec3 fill) {
+    float brightness = 0.2126 * fill.r + 0.7152 * fill.g + 0.0722 * fill.b;
+    return (brightness > 0.75) ? vec3(0.11, 0.165, 0.208) : vec3(0.988, 0.988, 0.988);
+}
+
+// Silhouette edge detection & rendering algorithem by leoneruggiero
+// https://www.shadertoy.com/view/DslXz2
+#define INFLATE 1
+
+float GetTolerance(float d, float k)
+{
+    float A=-   (z_far+z_near)/(z_far-z_near);
+    float B=-2.0*z_far*z_near /(z_far-z_near);
+
+    d = d*2.0-1.0;
+
+    return -k*(d+A)*(d+A)/B;
+}
+
+float DetectSilho(vec2 fragCoord, vec2 dir)
+{
+    float x0 = abs(texture2D(depth_tex, (fragCoord + dir*-2.0) / screen_size).r);
+    float x1 = abs(texture2D(depth_tex, (fragCoord + dir*-1.0) / screen_size).r);
+    float x2 = abs(texture2D(depth_tex, (fragCoord + dir* 0.0) / screen_size).r);
+    float x3 = abs(texture2D(depth_tex, (fragCoord + dir* 1.0) / screen_size).r);
+
+    float d0 = (x1-x0);
+    float d1 = (x2-x3);
+
+    float r0 = x1 + d0 - x2;
+    float r1 = x2 + d1 - x1;
+
+    float tol = GetTolerance(x2, 0.04);
+
+    return smoothstep(0.0, tol*tol, max( - r0*r1, 0.0));
+
+}
+
+float DetectSilho(vec2 fragCoord)
+{
+    return max(
+        DetectSilho(fragCoord, vec2(1,0)),
+        DetectSilho(fragCoord, vec2(0,1))
+        );
+}
+
+void main()
+{
+    if (any(lessThan(clipping_planes_dots, ZERO)))
+        discard;
+
+    vec4 color;
+    if (use_color_clip_plane) {
+        color.rgb = (color_clip_plane_dot < 0.0) ? uniform_color_clip_plane_1.rgb : uniform_color_clip_plane_2.rgb;
+        color.a = uniform_color.a;
+    }
+    else
+        color = uniform_color;
+
+    if (slope.actived) {
+         if(world_pos.z<0.1&&world_pos.z>-0.1)
+         {
+                color.rgb = LightBlue;
+                color.a = 0.8;
+         }
+         else if( world_normal_z < slope.normal_z - EPSILON)
+         {
+                color.rgb = color.rgb * 0.5 + LightRed * 0.5;
+                color.a = 0.8;
+         }
+    }
+
+    vec3 pv_check_min = ZERO;
+    vec3 pv_check_max = ZERO;
+    if (print_volume.type == 0) {
+        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) {
+        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.rgb = (any(lessThan(pv_check_min, ZERO)) || any(greaterThan(pv_check_max, ZERO))) ? mix(color.rgb, ZERO, 0.3333) : color.rgb;
+
+    vec3 normal = normalize(eye_normal);
+    vec3 view_dir = normalize(-eye_position);
+
+    float NdotL_top = max(dot(normal, LIGHT_TOP_DIR), 0.0);
+    float diffuse = INTENSITY_AMBIENT + NdotL_top * LIGHT_TOP_DIFFUSE;
+    vec3 half_top = normalize(LIGHT_TOP_DIR + view_dir);
+    float specular = LIGHT_TOP_SPECULAR * pow(max(dot(normal, half_top), 0.0), LIGHT_TOP_SHININESS);
+
+    float NdotL_front = max(dot(normal, LIGHT_FRONT_DIR), 0.0);
+    diffuse += NdotL_front * LIGHT_FRONT_DIFFUSE;
+    vec3 half_front = normalize(LIGHT_FRONT_DIR + view_dir);
+    specular += LIGHT_FRONT_SPECULAR * pow(max(dot(normal, half_front), 0.0), LIGHT_FRONT_SHININESS);
+
+    if (is_outline) {
+        vec4 shaded_color = vec4(vec3(specular) + color.rgb * diffuse, color.a);
+        vec2 fragCoord = gl_FragCoord.xy;
+        float s = DetectSilho(fragCoord);
+        for(int i=1;i<=INFLATE; i++)
+        {
+           s = max(s, DetectSilho(fragCoord.xy + vec2(i, 0)));
+           s = max(s, DetectSilho(fragCoord.xy + vec2(0, i)));
+        }
+        gl_FragColor = vec4(mix(shaded_color.rgb, getBackfaceColor(shaded_color.rgb), s), shaded_color.a);
+    }
+#ifdef ENABLE_ENVIRONMENT_MAP
+    else if (use_environment_tex)
+        gl_FragColor = vec4(0.45 * texture2D(environment_tex, normalize(eye_normal).xy * 0.5 + 0.5).xyz + 0.8 * color.rgb * diffuse, color.a);
+#endif
+    else
+        gl_FragColor = vec4(vec3(specular) + color.rgb * diffuse, color.a);
+}

resources/shaders/110/phong.vs

@@ -0,0 +1,54 @@
+#version 110
+
+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;
+// Color clip plane - general orientation. Used by the cut gizmo.
+uniform vec4 color_clip_plane;
+
+attribute vec3 v_position;
+attribute vec3 v_normal;
+
+varying vec3 clipping_planes_dots;
+varying float color_clip_plane_dot;
+
+varying vec4 world_pos;
+varying float world_normal_z;
+varying vec3 eye_normal;
+varying vec3 eye_position;
+
+void main()
+{
+    // First transform the normal into camera space and normalize the result.
+    eye_normal = normalize(view_normal_matrix * v_normal);
+
+    vec4 position = view_model_matrix * vec4(v_position, 1.0);
+    eye_position = position.xyz;
+
+    // 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);
+    color_clip_plane_dot = dot(world_pos, color_clip_plane);
+}

resources/shaders/140/phong.fs

@@ -0,0 +1,192 @@
+#version 140
+
+const vec3 ZERO = vec3(0.0, 0.0, 0.0);
+const vec3 LightRed = vec3(0.78, 0.0, 0.0);
+const vec3 LightBlue = vec3(0.73, 1.0, 1.0);
+const float EPSILON = 0.0001;
+
+#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.85 * INTENSITY_CORRECTION)
+#define LIGHT_TOP_SHININESS  72.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.20 * INTENSITY_CORRECTION)
+#define LIGHT_FRONT_SHININESS 28.0
+#define LIGHT_FRONT_SPECULAR (0.20 * INTENSITY_CORRECTION)
+#define LIGHT_FRONT_SHININESS 28.0
+
+#define INTENSITY_AMBIENT    0.22
+
+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 bool use_color_clip_plane;
+uniform vec4 uniform_color_clip_plane_1;
+uniform vec4 uniform_color_clip_plane_2;
+uniform SlopeDetection slope;
+
+//BBS: add outline_color
+uniform bool is_outline;
+uniform sampler2D depth_tex;
+uniform vec2 screen_size;
+
+#ifdef ENABLE_ENVIRONMENT_MAP
+    uniform sampler2D environment_tex;
+    uniform bool use_environment_tex;
+#endif // ENABLE_ENVIRONMENT_MAP
+
+uniform PrintVolumeDetection print_volume;
+
+uniform float z_far;
+uniform float z_near;
+
+in vec3 clipping_planes_dots;
+in float color_clip_plane_dot;
+
+in vec4 world_pos;
+in float world_normal_z;
+in vec3 eye_normal;
+in vec3 eye_position;
+
+out vec4 out_color;
+
+vec3 getBackfaceColor(vec3 fill) {
+    float brightness = 0.2126 * fill.r + 0.7152 * fill.g + 0.0722 * fill.b;
+    return (brightness > 0.75) ? vec3(0.11, 0.165, 0.208) : vec3(0.988, 0.988, 0.988);
+}
+
+// Silhouette edge detection & rendering algorithem by leoneruggiero
+// https://www.shadertoy.com/view/DslXz2
+#define INFLATE 1
+
+float GetTolerance(float d, float k)
+{
+    float A=-   (z_far+z_near)/(z_far-z_near);
+    float B=-2.0*z_far*z_near /(z_far-z_near);
+
+    d = d*2.0-1.0;
+
+    return -k*(d+A)*(d+A)/B;
+}
+
+float DetectSilho(vec2 fragCoord, vec2 dir)
+{
+    float x0 = abs(texture(depth_tex, (fragCoord + dir*-2.0) / screen_size).r);
+    float x1 = abs(texture(depth_tex, (fragCoord + dir*-1.0) / screen_size).r);
+    float x2 = abs(texture(depth_tex, (fragCoord + dir* 0.0) / screen_size).r);
+    float x3 = abs(texture(depth_tex, (fragCoord + dir* 1.0) / screen_size).r);
+
+    float d0 = (x1-x0);
+    float d1 = (x2-x3);
+
+    float r0 = x1 + d0 - x2;
+    float r1 = x2 + d1 - x1;
+
+    float tol = GetTolerance(x2, 0.04);
+
+    return smoothstep(0.0, tol*tol, max( - r0*r1, 0.0));
+
+}
+
+float DetectSilho(vec2 fragCoord)
+{
+    return max(
+        DetectSilho(fragCoord, vec2(1,0)),
+        DetectSilho(fragCoord, vec2(0,1))
+        );
+}
+
+void main()
+{
+    if (any(lessThan(clipping_planes_dots, ZERO)))
+        discard;
+
+    vec4 color;
+    if (use_color_clip_plane) {
+        color.rgb = (color_clip_plane_dot < 0.0) ? uniform_color_clip_plane_1.rgb : uniform_color_clip_plane_2.rgb;
+        color.a = uniform_color.a;
+    }
+    else
+        color = uniform_color;
+
+    if (slope.actived) {
+         if(world_pos.z<0.1&&world_pos.z>-0.1)
+         {
+                color.rgb = LightBlue;
+                color.a = 0.8;
+         }
+         else if( world_normal_z < slope.normal_z - EPSILON)
+         {
+                color.rgb = color.rgb * 0.5 + LightRed * 0.5;
+                color.a = 0.8;
+         }
+    }
+
+    vec3 pv_check_min = ZERO;
+    vec3 pv_check_max = ZERO;
+    if (print_volume.type == 0) {
+        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) {
+        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.rgb = (any(lessThan(pv_check_min, ZERO)) || any(greaterThan(pv_check_max, ZERO))) ? mix(color.rgb, ZERO, 0.3333) : color.rgb;
+
+    vec3 normal = normalize(eye_normal);
+    vec3 view_dir = normalize(-eye_position);
+
+    float NdotL_top = max(dot(normal, LIGHT_TOP_DIR), 0.0);
+    float diffuse = INTENSITY_AMBIENT + NdotL_top * LIGHT_TOP_DIFFUSE;
+    vec3 half_top = normalize(LIGHT_TOP_DIR + view_dir);
+    float specular = LIGHT_TOP_SPECULAR * pow(max(dot(normal, half_top), 0.0), LIGHT_TOP_SHININESS);
+
+    float NdotL_front = max(dot(normal, LIGHT_FRONT_DIR), 0.0);
+    diffuse += NdotL_front * LIGHT_FRONT_DIFFUSE;
+    vec3 half_front = normalize(LIGHT_FRONT_DIR + view_dir);
+    specular += LIGHT_FRONT_SPECULAR * pow(max(dot(normal, half_front), 0.0), LIGHT_FRONT_SHININESS);
+
+    if (is_outline) {
+        vec4 shaded_color = vec4(vec3(specular) + color.rgb * diffuse, color.a);
+        vec2 fragCoord = gl_FragCoord.xy;
+        float s = DetectSilho(fragCoord);
+        for(int i=1;i<=INFLATE; i++)
+        {
+           s = max(s, DetectSilho(fragCoord.xy + vec2(i, 0)));
+           s = max(s, DetectSilho(fragCoord.xy + vec2(0, i)));
+        }
+        out_color = vec4(mix(shaded_color.rgb, getBackfaceColor(shaded_color.rgb), s), shaded_color.a);
+    }
+#ifdef ENABLE_ENVIRONMENT_MAP
+    else if (use_environment_tex)
+        out_color = vec4(0.45 * texture(environment_tex, normalize(eye_normal).xy * 0.5 + 0.5).xyz + 0.8 * color.rgb * diffuse, color.a);
+#endif
+    else
+        out_color = vec4(vec3(specular) + color.rgb * diffuse, color.a);
+}

resources/shaders/140/phong.vs

@@ -0,0 +1,54 @@
+#version 140
+
+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;
+// Color clip plane - general orientation. Used by the cut gizmo.
+uniform vec4 color_clip_plane;
+
+in vec3 v_position;
+in vec3 v_normal;
+
+out vec3 clipping_planes_dots;
+out float color_clip_plane_dot;
+
+out vec4 world_pos;
+out float world_normal_z;
+out vec3 eye_normal;
+out vec3 eye_position;
+
+void main()
+{
+    // First transform the normal into camera space and normalize the result.
+    eye_normal = normalize(view_normal_matrix * v_normal);
+
+    vec4 position = view_model_matrix * vec4(v_position, 1.0);
+    eye_position = position.xyz;
+
+    // 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);
+    color_clip_plane_dot = dot(world_pos, color_clip_plane);
+}

src/libslic3r/AppConfig.cpp

@@ -259,6 +259,9 @@ void AppConfig::set_defaults()
     if (get(SETTING_OPENGL_SHOW_FPS_OVERLAY).empty())
         set_bool(SETTING_OPENGL_SHOW_FPS_OVERLAY, false);
 
+    if (get(SETTING_OPENGL_SHADING_MODEL).empty())
+        set(SETTING_OPENGL_SHADING_MODEL, "gouraud");
+
     if (get("export_sources_full_pathnames").empty())
         set_bool("export_sources_full_pathnames", false);
 

src/libslic3r/AppConfig.hpp

@@ -34,6 +34,7 @@ using namespace nlohmann;
 #define SETTING_OPENGL_FXAA_ENABLED "opengl_fxaa_enabled"
 #define SETTING_OPENGL_FPS_CAP "opengl_fps_cap"
 #define SETTING_OPENGL_SHOW_FPS_OVERLAY "opengl_show_fps_overlay"
+#define SETTING_OPENGL_SHADING_MODEL "opengl_shading_model"
 
 #if defined(_WIN32) || defined(_WIN64)
 #define BAMBU_NETWORK_AGENT_VERSION_LEGACY "01.10.01.09"

src/slic3r/GUI/GLCanvas3D.cpp

@@ -7756,7 +7756,11 @@ void GLCanvas3D::_render_objects(GLVolumeCollection::ERenderType type, bool with
     else
         m_volumes.set_show_sinking_contours(!m_gizmos.is_hiding_instances());
 
-    GLShaderProgram* shader = wxGetApp().get_shader("gouraud");
+    const std::string shading_model = wxGetApp().app_config->get(SETTING_OPENGL_SHADING_MODEL);
+    const std::string shader_name = (shading_model == "phong") ? "phong" : "gouraud";
+    GLShaderProgram* shader = wxGetApp().get_shader(shader_name);
+    if (shader == nullptr && shader_name != "gouraud")
+        shader = wxGetApp().get_shader("gouraud");
     ECanvasType canvas_type = this->m_canvas_type;
     bool                 partly_inside_enable = canvas_type == ECanvasType::CanvasAssembleView ? false : true;
     if (shader != nullptr) {

src/slic3r/GUI/GLShadersManager.cpp

@@ -76,6 +76,12 @@ std::pair<bool, std::string> GLShadersManager::init()
     valid &= append_shader("gouraud", { prefix + "gouraud.vs", prefix + "gouraud.fs" }
 #if ENABLE_ENVIRONMENT_MAP
         , { "ENABLE_ENVIRONMENT_MAP"sv }
+#endif // ENABLE_ENVIRONMENT_MAP
+        );
+    // used to render objects in 3d editor with phong shading
+    valid &= append_shader("phong", { prefix + "phong.vs", prefix + "phong.fs" }
+#if ENABLE_ENVIRONMENT_MAP
+        , { "ENABLE_ENVIRONMENT_MAP"sv }
 #endif // ENABLE_ENVIRONMENT_MAP
         );
     // used to render variable layers heights in 3d editor

src/slic3r/GUI/Preferences.cpp

@@ -1565,6 +1565,18 @@ void PreferencesDialog::create_items()
     );
     g_sizer->Add(item_fxaa);
 
+    auto item_shading_model = create_item_combobox(
+        _L("Shader"),
+        _L("Select 3D viewport shading model.\n"
+           "Gouraud: faster, per-vertex lighting.\n"
+           "Phong: smoother, per-fragment lighting.\n\n"
+           "Takes effect immediately."),
+        SETTING_OPENGL_SHADING_MODEL,
+        {_L("Gouraud"), _L("Phong")},
+        {"gouraud", "phong"}
+    );
+    g_sizer->Add(item_shading_model);
+
     //// GRAPHICS > FPS
     g_sizer->Add(create_item_title(_L("FPS")), 1, wxEXPAND);