Merge branch 'master' into blender2.8
[blender.git] / source / blender / gpu / shaders / gpu_shader_basic_frag.glsl
index 7b4df51c12daec5a7c3821ec47dd4b1afbc94285..ad4182340d63153d744880cc4269be7ad5148cdc 100644 (file)
 #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
@@ -45,91 +48,103 @@ uniform sampler2D texture_map;
 
 #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)
-        /* 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
+#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)
@@ -150,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 */
@@ -158,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
@@ -166,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++) {
@@ -197,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 */
@@ -212,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
@@ -242,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 */