Merge branch 'master' into blender2.8
[blender.git] / source / blender / gpu / shaders / gpu_shader_basic_frag.glsl
index 94c73d9e24886f375ed15ec1e96e36993ba59d90..ad4182340d63153d744880cc4269be7ad5148cdc 100644 (file)
 #define NUM_SOLID_LIGHTS 3
 #define NUM_SCENE_LIGHTS 8
 
+/* Keep these in sync with GPU_basic_shader.h */
+#define STIPPLE_HALFTONE                               0
+#define STIPPLE_QUARTTONE                              1
+#define STIPPLE_CHECKER_8PX                            2
+#define STIPPLE_HEXAGON                                3
+#define STIPPLE_DIAG_STRIPES                           4
+#define STIPPLE_DIAG_STRIPES_SWAP                      5
+#define STIPPLE_S3D_INTERLACE_ROW                      6
+#define STIPPLE_S3D_INTERLACE_ROW_SWAP                 7
+#define STIPPLE_S3D_INTERLACE_COLUMN                   8
+#define STIPPLE_S3D_INTERLACE_COLUMN_SWAP              9
+#define STIPPLE_S3D_INTERLACE_CHECKERBOARD             10
+#define STIPPLE_S3D_INTERLACE_CHECKERBOARD_SWAP        11
+
 #if defined(USE_SOLID_LIGHTING) || defined(USE_SCENE_LIGHTING)
+#if defined(USE_FLAT_NORMAL)
+varying vec3 eyespace_vert_pos;
+#else
 varying vec3 varying_normal;
-
+#endif
 #ifndef USE_SOLID_LIGHTING
 varying vec3 varying_position;
 #endif
@@ -29,11 +46,105 @@ varying vec2 varying_texture_coord;
 uniform sampler2D texture_map;
 #endif
 
+#ifdef USE_STIPPLE
+uniform int stipple_id;
+#if defined(DRAW_LINE)
+varying in float t;
+uniform int stipple_pattern;
+#endif
+#endif
+
 void main()
 {
+#if defined(USE_STIPPLE)
+#if defined(DRAW_LINE)
+       /* GLSL 1.3 */
+       if (!bool((1 << int(mod(t, 16))) & stipple_pattern))
+               discard;
+#else
+       /* We have to use mod function and integer casting.
+        * This can be optimized further with the bitwise operations
+        * when GLSL 1.3 is supported. */
+       if (stipple_id == STIPPLE_HALFTONE ||
+           stipple_id == STIPPLE_S3D_INTERLACE_CHECKERBOARD ||
+           stipple_id == STIPPLE_S3D_INTERLACE_CHECKERBOARD_SWAP)
+       {
+               int result = int(mod(gl_FragCoord.x + gl_FragCoord.y, 2));
+               bool dis = result == 0;
+               if (stipple_id == STIPPLE_S3D_INTERLACE_CHECKERBOARD_SWAP)
+                       dis = !dis;
+               if (dis)
+                       discard;
+       }
+       else if (stipple_id == STIPPLE_QUARTTONE) {
+               int mody = int(mod(gl_FragCoord.y, 4));
+               int modx = int(mod(gl_FragCoord.x, 4));
+               if (mody == 0) {
+                       if (modx != 2)
+                               discard;
+               }
+               else if (mody == 2) {
+                       if (modx != 0)
+                               discard;
+               }
+               else
+                       discard;
+       }
+       else if (stipple_id == STIPPLE_CHECKER_8PX) {
+               int result = int(mod(int(gl_FragCoord.x) / 8 + int(gl_FragCoord.y) / 8, 2));
+               if (result != 0)
+                       discard;
+       }
+       else if (stipple_id == STIPPLE_DIAG_STRIPES) {
+               int mody = int(mod(gl_FragCoord.y, 16));
+               int modx = int(mod(gl_FragCoord.x, 16));
+               if ((16 - modx > mody && mody > 8 - modx) || mody > 24 - modx)
+                       discard;
+       }
+       else if (stipple_id == STIPPLE_DIAG_STRIPES_SWAP) {
+               int mody = int(mod(gl_FragCoord.y, 16));
+               int modx = int(mod(gl_FragCoord.x, 16));
+               if (!((16 - modx > mody && mody > 8 - modx) || mody > 24 - modx))
+                       discard;
+       }
+       else if (stipple_id == STIPPLE_S3D_INTERLACE_ROW || stipple_id == STIPPLE_S3D_INTERLACE_ROW_SWAP) {
+               int result = int(mod(gl_FragCoord.y, 2));
+               bool dis = result == 0;
+               if (stipple_id == STIPPLE_S3D_INTERLACE_ROW_SWAP)
+                       dis = !dis;
+               if (dis)
+                       discard;
+       }
+       else if (stipple_id == STIPPLE_S3D_INTERLACE_COLUMN || stipple_id == STIPPLE_S3D_INTERLACE_COLUMN_SWAP) {
+               int result = int(mod(gl_FragCoord.x, 2));
+               bool dis = result != 0;
+               if (stipple_id == STIPPLE_S3D_INTERLACE_COLUMN_SWAP)
+                       dis = !dis;
+               if (dis)
+                       discard;
+       }
+       else if (stipple_id == STIPPLE_HEXAGON) {
+               int mody = int(mod(gl_FragCoord.y, 2));
+               int modx = int(mod(gl_FragCoord.x, 4));
+               if (mody != 0) {
+                       if (modx != 1)
+                               discard;
+               }
+               else {
+                       if (modx != 3)
+                               discard;
+               }
+       }
+#endif /* !DRAW_LINE */
+#endif /* USE_STIPPLE */
+
 #if defined(USE_SOLID_LIGHTING) || defined(USE_SCENE_LIGHTING)
        /* compute normal */
+#if defined(USE_FLAT_NORMAL)
+       vec3 N = normalize(cross(dFdx(eyespace_vert_pos), dFdy(eyespace_vert_pos)));
+#else
        vec3 N = normalize(varying_normal);
+#endif
 
 #ifdef USE_TWO_SIDED
        if (!gl_FrontFacing)
@@ -54,7 +165,7 @@ void main()
                /* diffuse light */
                vec3 light_diffuse = gl_LightSource[i].diffuse.rgb;
                float diffuse_bsdf = max(dot(N, light_direction), 0.0);
-               L_diffuse += light_diffuse*diffuse_bsdf;
+               L_diffuse += light_diffuse * diffuse_bsdf;
 
 #ifndef NO_SPECULAR
                /* specular light */
@@ -62,7 +173,7 @@ void main()
                vec3 H = gl_LightSource[i].halfVector.xyz;
 
                float specular_bsdf = pow(max(dot(N, H), 0.0), gl_FrontMaterial.shininess);
-               L_specular += light_specular*specular_bsdf;
+               L_specular += light_specular * specular_bsdf;
 #endif
        }
 #else
@@ -70,7 +181,7 @@ void main()
 
 #ifndef NO_SPECULAR
        /* view vector computation, depends on orthographics or perspective */
-       vec3 V = (gl_ProjectionMatrix[3][3] == 0.0) ? normalize(varying_position): vec3(0.0, 0.0, -1.0);
+       vec3 V = (gl_ProjectionMatrix[3][3] == 0.0) ? normalize(varying_position) : vec3(0.0, 0.0, -1.0);
 #endif
 
        for (int i = 0; i < NUM_SCENE_LIGHTS; i++) {
@@ -101,14 +212,14 @@ void main()
                        float distance = length(d);
 
                        intensity /= gl_LightSource[i].constantAttenuation +
-                               gl_LightSource[i].linearAttenuation * distance +
-                               gl_LightSource[i].quadraticAttenuation * distance * distance;
+                                    gl_LightSource[i].linearAttenuation * distance +
+                                    gl_LightSource[i].quadraticAttenuation * distance * distance;
                }
 
                /* diffuse light */
                vec3 light_diffuse = gl_LightSource[i].diffuse.rgb;
                float diffuse_bsdf = max(dot(N, light_direction), 0.0);
-               L_diffuse += light_diffuse*diffuse_bsdf*intensity;
+               L_diffuse += light_diffuse * diffuse_bsdf * intensity;
 
 #ifndef NO_SPECULAR
                /* specular light */
@@ -116,7 +227,7 @@ void main()
                vec3 H = normalize(light_direction - V);
 
                float specular_bsdf = pow(max(dot(N, H), 0.0), gl_FrontMaterial.shininess);
-               L_specular += light_specular*specular_bsdf*intensity;
+               L_specular += light_specular * specular_bsdf * intensity;
 #endif
        }
 #endif
@@ -146,7 +257,7 @@ void main()
        vec3 L = gl_FrontLightModelProduct.sceneColor.rgb + L_diffuse;
 
 #ifndef NO_SPECULAR
-       L += L_specular*gl_FrontMaterial.specular.rgb;
+       L += L_specular * gl_FrontMaterial.specular.rgb;
 #endif
 
        /* write out fragment color */