Fix T49861: Interlace stereo drawing

This does not address stapling shader in 2.8, though the solution can be
similar (own shader, not polutting interlace shader).

part of T49043

Reviewers: merwin

Differential Revision: https://developer.blender.org/D2440

source/blender/gpu/CMakeLists.txt

@@ -142,6 +142,7 @@ data_to_c_simple(shaders/gpu_shader_image_modulate_alpha_frag.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_image_color_frag.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_image_rect_modulate_alpha_frag.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_image_depth_linear_frag.glsl SRC)
+data_to_c_simple(shaders/gpu_shader_image_interlace_frag.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_3D_image_vert.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_3D_vert.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_3D_flat_color_vert.glsl SRC)

source/blender/gpu/GPU_basic_shader.h

@@ -64,12 +64,6 @@ typedef enum GPUBasicShaderStipple {
 	GPU_SHADER_STIPPLE_HEXAGON                         = 3,
 	GPU_SHADER_STIPPLE_DIAG_STRIPES                    = 4,
 	GPU_SHADER_STIPPLE_DIAG_STRIPES_SWAP               = 5,
-	GPU_SHADER_STIPPLE_S3D_INTERLACE_ROW               = 6,
-	GPU_SHADER_STIPPLE_S3D_INTERLACE_ROW_SWAP          = 7,
-	GPU_SHADER_STIPPLE_S3D_INTERLACE_COLUMN            = 8,
-	GPU_SHADER_STIPPLE_S3D_INTERLACE_COLUMN_SWAP       = 9,
-	GPU_SHADER_STIPPLE_S3D_INTERLACE_CHECKER           = 10,
-	GPU_SHADER_STIPPLE_S3D_INTERLACE_CHECKER_SWAP      = 11
 } GPUBasicShaderStipple;
 
 void GPU_basic_shaders_init(void);

source/blender/gpu/GPU_shader.h

@@ -112,6 +112,8 @@ typedef enum GPUBuiltinShader {
 	GPU_SHADER_3D_IMAGE_MODULATE_ALPHA,
 	GPU_SHADER_3D_IMAGE_RECT_MODULATE_ALPHA,
 	GPU_SHADER_3D_IMAGE_DEPTH,
+	/* stereo 3d */
+	GPU_SHADER_2D_IMAGE_INTERLACE,
 	/* points */
 	GPU_SHADER_2D_POINT_FIXED_SIZE_UNIFORM_COLOR,
 	GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_SMOOTH,
@@ -128,6 +130,16 @@ typedef enum GPUBuiltinShader {
 	GPU_NUM_BUILTIN_SHADERS /* (not an actual shader) */
 } GPUBuiltinShader;
 
+/* Keep these in sync with:
+ *  gpu_shader_image_interlace_frag.glsl
+ *  gpu_shader_image_rect_interlace_frag.glsl
+ **/
+typedef enum GPUInterlaceShader {
+	GPU_SHADER_INTERLACE_ROW               = 0,
+	GPU_SHADER_INTERLACE_COLUMN            = 1,
+	GPU_SHADER_INTERLACE_CHECKER           = 2,
+} GPUInterlaceShader;
+
 GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader);
 GPUShader *GPU_shader_get_builtin_fx_shader(int effects, bool persp);
 

source/blender/gpu/intern/gpu_basic_shader.c

@@ -140,114 +140,6 @@ const GLubyte stipple_checker_8px[128] = {
 	0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255,
 	0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255};
 
-const GLubyte stipple_interlace_row[128] = {
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00};
-
-const GLubyte stipple_interlace_row_swap[128] = {
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
-	0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff};
-
-const GLubyte stipple_interlace_column[128] = {
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
-	0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
-
-const GLubyte stipple_interlace_column_swap[128] = {
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa};
-
-const GLubyte stipple_interlace_checker[128] = {
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa,
-	0x55, 0x55, 0x55, 0x55, 0xaa, 0xaa, 0xaa, 0xaa};
-
-const GLubyte stipple_interlace_checker_swap[128] = {
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55,
-	0xaa, 0xaa, 0xaa, 0xaa, 0x55, 0x55, 0x55, 0x55};
-
 const GLubyte stipple_hexagon[128] = {
 	0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
 	0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
@@ -651,24 +543,6 @@ void GPU_basic_shader_stipple(GPUBasicShaderStipple stipple_id)
 			case GPU_SHADER_STIPPLE_DIAG_STRIPES:
 				glPolygonStipple(stipple_diag_stripes_pos);
 				return;
-			case GPU_SHADER_STIPPLE_S3D_INTERLACE_ROW:
-				glPolygonStipple(stipple_interlace_row);
-				return;
-			case GPU_SHADER_STIPPLE_S3D_INTERLACE_ROW_SWAP:
-				glPolygonStipple(stipple_interlace_row_swap);
-				return;
-			case GPU_SHADER_STIPPLE_S3D_INTERLACE_COLUMN:
-				glPolygonStipple(stipple_interlace_column);
-				return;
-			case GPU_SHADER_STIPPLE_S3D_INTERLACE_COLUMN_SWAP:
-				glPolygonStipple(stipple_interlace_column_swap);
-				return;
-			case GPU_SHADER_STIPPLE_S3D_INTERLACE_CHECKER:
-				glPolygonStipple(stipple_interlace_checker);
-				return;
-			case GPU_SHADER_STIPPLE_S3D_INTERLACE_CHECKER_SWAP:
-				glPolygonStipple(stipple_interlace_checker_swap);
-				return;
 			default:
 				glPolygonStipple(stipple_hexagon);
 				return;

source/blender/gpu/intern/gpu_shader.c

@@ -58,6 +58,7 @@ extern char datatoc_gpu_shader_2D_image_vert_glsl[];
 
 extern char datatoc_gpu_shader_3D_image_vert_glsl[];
 extern char datatoc_gpu_shader_image_color_frag_glsl[];
+extern char datatoc_gpu_shader_image_interlace_frag_glsl[];
 extern char datatoc_gpu_shader_image_mask_uniform_color_frag_glsl[];
 extern char datatoc_gpu_shader_image_modulate_alpha_frag_glsl[];
 extern char datatoc_gpu_shader_image_rect_modulate_alpha_frag_glsl[];
@@ -633,6 +634,9 @@ GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
 		[GPU_SHADER_3D_IMAGE_DEPTH] = { datatoc_gpu_shader_3D_image_vert_glsl,
 		                                datatoc_gpu_shader_image_depth_linear_frag_glsl },
 
+	    [GPU_SHADER_2D_IMAGE_INTERLACE] = { datatoc_gpu_shader_2D_image_vert_glsl,
+	                                        datatoc_gpu_shader_image_interlace_frag_glsl },
+
 		[GPU_SHADER_2D_UNIFORM_COLOR] = { datatoc_gpu_shader_2D_vert_glsl, datatoc_gpu_shader_uniform_color_frag_glsl },
 		[GPU_SHADER_2D_FLAT_COLOR] = { datatoc_gpu_shader_2D_flat_color_vert_glsl,
 		                               datatoc_gpu_shader_flat_color_frag_glsl },

source/blender/gpu/shaders/gpu_shader_basic_frag.glsl

@@ -20,12 +20,6 @@
 #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)
@@ -74,14 +68,9 @@ void main()
 	/* 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 ||
+	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;
 	}
@@ -116,22 +105,6 @@ void main()
 		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));

source/blender/gpu/shaders/gpu_shader_image_interlace_frag.glsl

@@ -0,0 +1,52 @@
+
+/* Keep these in sync with GPU_shader.h */
+#define INTERLACE_ROW                      0
+#define INTERLACE_COLUMN                   1
+#define INTERLACE_CHECKERBOARD             2
+
+#if __VERSION__ == 120
+  varying vec2 texCoord_interp;
+  #define fragColor gl_FragColor
+#else
+  in vec2 texCoord_interp;
+  out vec4 fragColor;
+  #define texture2DRect texture
+#endif
+
+uniform int interlace_id;
+uniform sampler2DRect image_a;
+uniform sampler2DRect image_b;
+
+bool interlace()
+{
+#if __VERSION__ == 120
+	if (interlace_id == INTERLACE_CHECKERBOARD) {
+		return int(mod(gl_FragCoord.x + gl_FragCoord.y, 2)) != 0;
+	}
+	else if (interlace_id == INTERLACE_ROW) {
+		return int(mod(gl_FragCoord.y, 2)) != 0;
+	}
+	else if (interlace_id == INTERLACE_COLUMN) {
+		return int(mod(gl_FragCoord.x, 2)) != 0;
+	}
+#else
+	if (interlace_id == INTERLACE_CHECKERBOARD) {
+		return (int(gl_FragCoord.x + gl_FragCoord.y) & 1) != 0;
+	}
+	else if (interlace_id == INTERLACE_ROW) {
+		return (int(gl_FragCoord.y) & 1) != 0;
+	}
+	else if (interlace_id == INTERLACE_COLUMN) {
+		return (int(gl_FragCoord.x) & 1) != 0;
+	}
+#endif
+}
+
+void main()
+{
+	if (interlace()) {
+		fragColor = texture2DRect(image_a, texCoord_interp);
+	} else {
+		fragColor = texture2DRect(image_b, texCoord_interp);
+	}
+}

source/blender/windowmanager/intern/wm_draw.c

@@ -80,8 +80,6 @@
 #define WIN_FRONT_OK    2
 #define WIN_BOTH_OK     3
 
-#define USE_TEXTURE_RECTANGLE 1
-
 /* ******************* drawing, overlays *************** */
 
 
@@ -426,8 +424,7 @@ static bool wm_triple_gen_textures(wmWindow *win, wmDrawTriple *triple)
 	return true;
 }
 
-/* TODO: fix interface - T49861 */
+void wm_triple_draw_textures(wmWindow *win, wmDrawTriple *triple, float alpha)
-void wm_triple_draw_textures(wmWindow *win, wmDrawTriple *triple, float alpha, bool UNUSED(is_interlace))
 {
 	const int sizex = WM_window_pixels_x(win);
 	const int sizey = WM_window_pixels_y(win);
@@ -508,7 +505,7 @@ static void wm_draw_region_blend(wmWindow *win, ARegion *ar, wmDrawTriple *tripl
 		wmSubWindowScissorSet(win, win->screen->mainwin, &ar->winrct, true);
 
 		glEnable(GL_BLEND);
-		wm_triple_draw_textures(win, triple, 1.0f - fac, false);
+		wm_triple_draw_textures(win, triple, 1.0f - fac);
 		glDisable(GL_BLEND);
 	}
 }
@@ -530,7 +527,7 @@ static void wm_method_draw_triple(bContext *C, wmWindow *win)
 
 		wmSubWindowSet(win, screen->mainwin);
 
-		wm_triple_draw_textures(win, drawdata->triple, 1.0f, false);
+		wm_triple_draw_textures(win, drawdata->triple, 1.0f);
 	}
 	else {
 		/* we run it when we start OR when we turn stereo on */
@@ -671,7 +668,7 @@ static void wm_method_draw_triple_multiview(bContext *C, wmWindow *win, StereoVi
 
 				wmSubWindowSet(win, screen->mainwin);
 
-				wm_triple_draw_textures(win, drawdata->triple, 1.0f, false);
+				wm_triple_draw_textures(win, drawdata->triple, 1.0f);
 			}
 		}
 		else {

source/blender/windowmanager/intern/wm_stereo.c

@@ -78,54 +78,82 @@ static void wm_method_draw_stereo3d_pageflip(wmWindow *win)
 		else //STEREO_RIGHT_ID
 			glDrawBuffer(GL_BACK_RIGHT);
 
-		wm_triple_draw_textures(win, drawdata->triple, 1.0f, false);
+		wm_triple_draw_textures(win, drawdata->triple, 1.0f);
 	}
 
 	glDrawBuffer(GL_BACK);
 }
 
-static enum eStereo3dInterlaceType interlace_prev_type = -1;
+static GPUInterlaceShader interlace_gpu_id_from_type(eStereo3dInterlaceType interlace_type)
-static char interlace_prev_swap = -1;
+{
+	switch (interlace_type) {
+	    case S3D_INTERLACE_ROW:
+		    return GPU_SHADER_INTERLACE_ROW;
+	    case S3D_INTERLACE_COLUMN:
+		    return GPU_SHADER_INTERLACE_COLUMN;
+	    case S3D_INTERLACE_CHECKERBOARD:
+	    default:
+		    return GPU_SHADER_INTERLACE_CHECKER;
+	}
+}
 
 static void wm_method_draw_stereo3d_interlace(wmWindow *win)
 {
-	wmDrawData *drawdata;
-	int view;
-	bool flag;
 	bool swap = (win->stereo3d_format->flag & S3D_INTERLACE_SWAP) != 0;
 	enum eStereo3dInterlaceType interlace_type = win->stereo3d_format->interlace_type;
 
-	for (view = 0; view < 2; view ++) {
+	wmDrawData *drawdata[2];
-		flag = swap ? !view : view;
+	for (int eye = 0; eye < 2; eye++) {
-		drawdata = BLI_findlink(&win->drawdata, (view * 2) + 1);
+		int view = swap ? !eye : eye;
-		GPU_basic_shader_bind(GPU_SHADER_STIPPLE);
+		drawdata[eye] = BLI_findlink(&win->drawdata, (view * 2) + 1);
-		switch (interlace_type) {
+	}
-			case S3D_INTERLACE_ROW:
+
-				if (flag)
+	const int sizex = WM_window_pixels_x(win);
-					GPU_basic_shader_stipple(GPU_SHADER_STIPPLE_S3D_INTERLACE_ROW_SWAP);
+	const int sizey = WM_window_pixels_y(win);
-				else
+
-					GPU_basic_shader_stipple(GPU_SHADER_STIPPLE_S3D_INTERLACE_ROW);
+	/* wmOrtho for the screen has this same offset */
-				break;
+	float ratiox = sizex;
-			case S3D_INTERLACE_COLUMN:
+	float ratioy = sizey;
-				if (flag)
+	float halfx = GLA_PIXEL_OFS;
-					GPU_basic_shader_stipple(GPU_SHADER_STIPPLE_S3D_INTERLACE_COLUMN_SWAP);
+	float halfy = GLA_PIXEL_OFS;
-				else
+
-					GPU_basic_shader_stipple(GPU_SHADER_STIPPLE_S3D_INTERLACE_COLUMN);
+	VertexFormat *format = immVertexFormat();
-				break;
+	unsigned texcoord = add_attrib(format, "texCoord", GL_FLOAT, 2, KEEP_FLOAT);
-			case S3D_INTERLACE_CHECKERBOARD:
+	unsigned pos = add_attrib(format, "pos", GL_FLOAT, 2, KEEP_FLOAT);
-			default:
+
-				if (flag)
+	immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_INTERLACE);
-					GPU_basic_shader_stipple(GPU_SHADER_STIPPLE_S3D_INTERLACE_CHECKER_SWAP);
+
-				else
+	/* leave GL_TEXTURE0 as the latest bind texture */
-					GPU_basic_shader_stipple(GPU_SHADER_STIPPLE_S3D_INTERLACE_CHECKER);
+	for (int eye = 1; eye >= 0; eye--) {
-				break;
+		glActiveTexture(GL_TEXTURE0 + eye);
-		}
+		glBindTexture(drawdata[eye]->triple->target, drawdata[eye]->triple->bind);
-
+	}
-		wm_triple_draw_textures(win, drawdata->triple, 1.0f, true);
+
-		GPU_basic_shader_bind(GPU_SHADER_USE_COLOR);
+	immUniform1i("image_a", 0);
+	immUniform1i("image_b", 1);
+
+	immUniform1i("interlace_id", interlace_gpu_id_from_type(interlace_type));
+
+	immBegin(GL_QUADS, 4);
+
+	immAttrib2f(texcoord, halfx, halfy);
+	immVertex2f(pos, 0.0f, 0.0f);
+
+	immAttrib2f(texcoord, ratiox + halfx, halfy);
+	immVertex2f(pos, sizex, 0.0f);
+
+	immAttrib2f(texcoord, ratiox + halfx, ratioy + halfy);
+	immVertex2f(pos, sizex, sizey);
+
+	immAttrib2f(texcoord, halfx, ratioy + halfy);
+	immVertex2f(pos, 0.0f, sizey);
+
+	immEnd();
+	immUnbindProgram();
+
+	for (int eye = 0; eye < 2; eye++) {
+		glBindTexture(drawdata[eye]->triple->target, 0);
 	}
-	interlace_prev_type = interlace_type;
-	interlace_prev_swap = swap;
 }
 
 static void wm_method_draw_stereo3d_anaglyph(wmWindow *win)
@@ -158,7 +186,7 @@ static void wm_method_draw_stereo3d_anaglyph(wmWindow *win)
 				break;
 		}
 
-		wm_triple_draw_textures(win, drawdata->triple, 1.0f, false);
+		wm_triple_draw_textures(win, drawdata->triple, 1.0f);
 
 		glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 	}

source/blender/windowmanager/wm_draw.h

@@ -34,6 +34,8 @@
 
 #include "GPU_glew.h"
 
+#define USE_TEXTURE_RECTANGLE 1
+
 typedef struct wmDrawTriple {
 	GLuint bind;
 	int x, y;
@@ -56,7 +58,7 @@ void		wm_draw_region_clear	(struct wmWindow *win, struct ARegion *ar);
 
 void		wm_tag_redraw_overlay	(struct wmWindow *win, struct ARegion *ar);
 
-void		wm_triple_draw_textures	(struct wmWindow *win, struct wmDrawTriple *triple, float alpha, bool is_interlace);
+void		wm_triple_draw_textures	(struct wmWindow *win, struct wmDrawTriple *triple, float alpha);
 
 void		wm_draw_data_free		(struct wmWindow *win);