Getting rid of setlinestyle: Clip drawing code.

This one has been painful, it's doing lots of nifty conditional drawing
of all kind... Also, very nice illustration of how cumbersome it is to
use dashed shader currently, we really need to find a simpler way at
some point imho. But this is not critical issue either, for now we can
live with some uglyness like that. :/

1 files changed, 269 insertions, 98 deletions

diff --git a/source/blender/editors/space_clip/clip_draw.c b/source/blender/editors/space_clip/clip_draw.c
index ed0cf861e39..7edd5ca45d1 100644
--- a/source/blender/editors/space_clip/clip_draw.c
+++ b/source/blender/editors/space_clip/clip_draw.c
@@ -348,10 +348,14 @@ static void draw_stabilization_border(SpaceClip *sc, ARegion *ar, int width, int
 
 	/* draw boundary border for frame if stabilization is enabled */
 	if (sc->flag & SC_SHOW_STABLE && clip->tracking.stabilization.flag & TRACKING_2D_STABILIZATION) {
-		setlinestyle(3);
+		VertexFormat *format = immVertexFormat();
+		const uint shdr_dashed_pos = VertexFormat_add_attrib(format, "pos", COMP_F32, 2, KEEP_FLOAT);
+		const uint shdr_dashed_origin = VertexFormat_add_attrib(format, "line_origin", COMP_F32, 2, KEEP_FLOAT);
 
+		/* Exclusive OR allows to get orig value when second operand is 0,
+		 * and negative of orig value when second operand is 1. */
 		glEnable(GL_COLOR_LOGIC_OP);
-		glLogicOp(GL_NOR);
+		glLogicOp(GL_XOR);
 
 		gpuPushMatrix();
 		gpuTranslate2f(x, y);
@@ -359,20 +363,24 @@ static void draw_stabilization_border(SpaceClip *sc, ARegion *ar, int width, int
 		gpuScale2f(zoomx, zoomy);
 		gpuMultMatrix(sc->stabmat);
 
-		unsigned int pos = VertexFormat_add_attrib(immVertexFormat(), "pos", COMP_F32, 2, KEEP_FLOAT);
+		immBindBuiltinProgram(GPU_SHADER_2D_LINE_DASHED_COLOR);
 
-		immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
-		immUniformColor3f(0.0f, 0.0f, 0.0f);
+		float viewport_size[4];
+		glGetFloatv(GL_VIEWPORT, viewport_size);
+		immUniform2f("viewport_size", viewport_size[2] / UI_DPI_FAC, viewport_size[3] / UI_DPI_FAC);
+
+		immUniform4f("color1", 1.0f, 1.0f, 1.0f, 0.0f);
+		immUniform4f("color2", 0.0f, 0.0f, 0.0f, 0.0f);
+		immUniform1f("dash_width", 6.0f);
+		immUniform1f("dash_width_on", 3.0f);
 
-		imm_draw_line_box(pos, 0.0f, 0.0f, width, height);
+		imm_draw_line_box_dashed(shdr_dashed_pos, shdr_dashed_origin, 0.0f, 0.0f, width, height);
 
 		immUnbindProgram();
 
 		gpuPopMatrix();
 
 		glDisable(GL_COLOR_LOGIC_OP);
-
-		setlinestyle(0);
 	}
 }
 
@@ -628,11 +636,16 @@ static void track_colors(MovieTrackingTrack *track, int act, float col[3], float
 }
 
 static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                              const float marker_pos[2], int width, int height, int act, int sel, unsigned int position)
+                              const float marker_pos[2], int width, int height, int act, int sel, const uint shdr_pos)
 {
 	int tiny = sc->flag & SC_SHOW_TINY_MARKER;
 	bool show_search = false;
-	float col[3], scol[3], px[2];
+	float *curr_col, other_col[3], col[3], scol[3];
+	float px[2];
+	bool is_dashed_shader = false;
+
+	/* Vertex attributes ids for dashed shader... */
+	uint shdr_dashed_pos, shdr_dashed_origin;
 
 	track_colors(track, act, col, scol);
 
@@ -647,18 +660,20 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 
 		if (track->flag & TRACK_LOCKED) {
 			if (act) {
-				immUniformThemeColor(TH_ACT_MARKER);
+				UI_GetThemeColor3fv(TH_ACT_MARKER, other_col);
 			}
 			else if (track->flag & SELECT) {
-				immUniformThemeColorShade(TH_LOCK_MARKER, 64);
+				UI_GetThemeColorShade3fv(TH_LOCK_MARKER, 64, other_col);
 			}
 			else {
-				immUniformThemeColor(TH_LOCK_MARKER);
+				UI_GetThemeColor3fv(TH_LOCK_MARKER, other_col);
 			}
+			curr_col = other_col;
 		}
 		else {
-			immUniformColor3fv((track->flag & SELECT) ? scol : col);
+			curr_col = (track->flag & SELECT) ? scol : col;
 		}
+		immUniformColor3fv(curr_col);
 
 		add_v2_v2v2(pos, marker->pos, track->offset);
 		ED_clip_point_undistorted_pos(sc, pos, pos);
@@ -671,40 +686,54 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 			glPointSize(tiny ? 1.0f : 2.0f);
 
 			immBegin(PRIM_POINTS, 1);
-			immVertex2f(position, pos[0], pos[1]);
+			immVertex2f(shdr_pos, pos[0], pos[1]);
 			immEnd();
 		}
 		else {
 			immBegin(PRIM_LINES, 8);
 
-			immVertex2f(position, pos[0] + px[0] * 3, pos[1]);
-			immVertex2f(position, pos[0] + px[0] * 7, pos[1]);
+			immVertex2f(shdr_pos, pos[0] + px[0] * 3, pos[1]);
+			immVertex2f(shdr_pos, pos[0] + px[0] * 7, pos[1]);
 
-			immVertex2f(position, pos[0] - px[0] * 3, pos[1]);
-			immVertex2f(position, pos[0] - px[0] * 7, pos[1]);
+			immVertex2f(shdr_pos, pos[0] - px[0] * 3, pos[1]);
+			immVertex2f(shdr_pos, pos[0] - px[0] * 7, pos[1]);
 
-			immVertex2f(position, pos[0], pos[1] - px[1] * 3);
-			immVertex2f(position, pos[0], pos[1] - px[1] * 7);
+			immVertex2f(shdr_pos, pos[0], pos[1] - px[1] * 3);
+			immVertex2f(shdr_pos, pos[0], pos[1] - px[1] * 7);
 
-			immVertex2f(position, pos[0], pos[1] + px[1] * 3);
-			immVertex2f(position, pos[0], pos[1] + px[1] * 7);
+			immVertex2f(shdr_pos, pos[0], pos[1] + px[1] * 3);
+			immVertex2f(shdr_pos, pos[0], pos[1] + px[1] * 7);
 
 			immEnd();
 
-			immUniformColor3f(0.0f, 0.0f, 0.0f);
-			setlinestyle(3);
+			immUnbindProgram();
+
+			is_dashed_shader = true;
+			VertexFormat *format = immVertexFormat();
+			shdr_dashed_pos = VertexFormat_add_attrib(format, "pos", COMP_F32, 2, KEEP_FLOAT);
+			shdr_dashed_origin = VertexFormat_add_attrib(format, "line_origin", COMP_F32, 2, KEEP_FLOAT);
+
+			immBindBuiltinProgram(GPU_SHADER_2D_LINE_DASHED_COLOR);
+
+			float viewport_size[4];
+			glGetFloatv(GL_VIEWPORT, viewport_size);
+			immUniform2f("viewport_size", viewport_size[2] / UI_DPI_FAC, viewport_size[3] / UI_DPI_FAC);
+
+			immUniform4f("color1", 1.0f, 1.0f, 1.0f, 0.0f);
+			immUniform4f("color2", 0.0f, 0.0f, 0.0f, 0.0f);
+			immUniform1f("dash_width", 6.0f);
+			immUniform1f("dash_width_on", 3.0f);
 
 			glEnable(GL_COLOR_LOGIC_OP);
-			glLogicOp(GL_NOR);
+			glLogicOp(GL_XOR);
 
 			immBegin(PRIM_LINES, 2);
-			immVertex2fv(position, pos);
-			immVertex2fv(position, marker_pos);
+			immAttrib2fv(shdr_dashed_origin, pos);
+			immVertex2fv(shdr_dashed_pos, pos);
+			immVertex2fv(shdr_dashed_pos, marker_pos);
 			immEnd();
 
 			glDisable(GL_COLOR_LOGIC_OP);
-
-			setlinestyle(0);
 		}
 	}
 
@@ -712,58 +741,123 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 	gpuPushMatrix();
 	gpuTranslate2fv(marker_pos);
 
-	if (tiny) {
-		setlinestyle(3);
-	}
-
 	if (track->flag & TRACK_LOCKED) {
 		if (act) {
-			immUniformThemeColor(TH_ACT_MARKER);
+			UI_GetThemeColor3fv(TH_ACT_MARKER, other_col);
 		}
 		else if (track->pat_flag & SELECT) {
-			immUniformThemeColorShade(TH_LOCK_MARKER, 64);
+			UI_GetThemeColorShade3fv(TH_LOCK_MARKER, 64, other_col);
 		}
 		else {
-			immUniformThemeColor(TH_LOCK_MARKER);
+			UI_GetThemeColor3fv(TH_LOCK_MARKER, other_col);
 		}
+		curr_col = other_col;
 	}
 	else if (marker->flag & MARKER_DISABLED) {
 		if (act) {
-			immUniformThemeColor(TH_ACT_MARKER);
+			UI_GetThemeColor3fv(TH_ACT_MARKER, other_col);
 		}
 		else if (track->pat_flag & SELECT) {
-			immUniformThemeColorShade(TH_DIS_MARKER, 128);
+			UI_GetThemeColorShade3fv(TH_DIS_MARKER, 128, other_col);
 		}
 		else {
-			immUniformThemeColor(TH_DIS_MARKER);
+			UI_GetThemeColor3fv(TH_DIS_MARKER, other_col);
 		}
+		curr_col = other_col;
 	}
 	else {
-		immUniformColor3fv((track->pat_flag & SELECT) ? scol : col);
+		curr_col = (track->pat_flag & SELECT) ? scol : col;
 	}
 
-	if ((track->pat_flag & SELECT) == sel && (sc->flag & SC_SHOW_MARKER_PATTERN)) {
-		immBegin(PRIM_LINE_LOOP, 4);
-		immVertex2fv(position, marker->pattern_corners[0]);
-		immVertex2fv(position, marker->pattern_corners[1]);
-		immVertex2fv(position, marker->pattern_corners[2]);
-		immVertex2fv(position, marker->pattern_corners[3]);
-		immEnd();
+	if (tiny) {
+		if (!is_dashed_shader) {
+			immUnbindProgram();
+
+			is_dashed_shader = true;
+			VertexFormat *format = immVertexFormat();
+			shdr_dashed_pos = VertexFormat_add_attrib(format, "pos", COMP_F32, 2, KEEP_FLOAT);
+			shdr_dashed_origin = VertexFormat_add_attrib(format, "line_origin", COMP_F32, 2, KEEP_FLOAT);
+
+			immBindBuiltinProgram(GPU_SHADER_2D_LINE_DASHED_COLOR);
+		}
+
+		glEnable(GL_BLEND);
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+		float viewport_size[4];
+		glGetFloatv(GL_VIEWPORT, viewport_size);
+		immUniform2f("viewport_size", viewport_size[2] / UI_DPI_FAC, viewport_size[3] / UI_DPI_FAC);
+
+		immUniform4f("color1", curr_col[0], curr_col[1], curr_col[2], 1.0f);
+		immUniform4f("color2", 0.0f, 0.0f, 0.0f, 0.0f);
+		immUniform1f("dash_width", 6.0f);
+		immUniform1f("dash_width_on", 3.0f);
+
+		if ((track->pat_flag & SELECT) == sel && (sc->flag & SC_SHOW_MARKER_PATTERN)) {
+			immBegin(PRIM_LINES, 8);
+			immAttrib2fv(shdr_dashed_origin, marker->pattern_corners[0]);
+			immVertex2fv(shdr_dashed_pos, marker->pattern_corners[0]);
+			immVertex2fv(shdr_dashed_pos, marker->pattern_corners[1]);
+
+			immAttrib2fv(shdr_dashed_origin, marker->pattern_corners[1]);
+			immVertex2fv(shdr_dashed_pos, marker->pattern_corners[1]);
+			immVertex2fv(shdr_dashed_pos, marker->pattern_corners[2]);
+
+			immAttrib2fv(shdr_dashed_origin, marker->pattern_corners[3]);
+			immVertex2fv(shdr_dashed_pos, marker->pattern_corners[2]);
+			immVertex2fv(shdr_dashed_pos, marker->pattern_corners[3]);
+
+			immAttrib2fv(shdr_dashed_origin, marker->pattern_corners[0]);
+			immVertex2fv(shdr_dashed_pos, marker->pattern_corners[3]);
+			immVertex2fv(shdr_dashed_pos, marker->pattern_corners[0]);
+			immEnd();
+		}
+
+		/* search */
+		show_search = (TRACK_VIEW_SELECTED(sc, track) &&
+		               ((marker->flag & MARKER_DISABLED) == 0 || (sc->flag & SC_SHOW_MARKER_PATTERN) == 0)) != 0;
+
+		if ((track->search_flag & SELECT) == sel && (sc->flag & SC_SHOW_MARKER_SEARCH) && show_search) {
+			imm_draw_line_box_dashed(shdr_dashed_pos, shdr_dashed_origin, marker->search_min[0], marker->search_min[1],
+			                                           marker->search_max[0], marker->search_max[1]);
+		}
+
+		glDisable(GL_BLEND);
 	}
 
-	/* search */
-	show_search = (TRACK_VIEW_SELECTED(sc, track) &&
-	               ((marker->flag & MARKER_DISABLED) == 0 || (sc->flag & SC_SHOW_MARKER_PATTERN) == 0)) != 0;
+	if (is_dashed_shader) {
+		immUnbindProgram();
 
-	if ((track->search_flag & SELECT) == sel && (sc->flag & SC_SHOW_MARKER_SEARCH) && show_search) {
-		imm_draw_line_box(position, marker->search_min[0],
-		                            marker->search_min[1],
-		                            marker->search_max[0],
-		                            marker->search_max[1]);
+		uint pos = VertexFormat_add_attrib(immVertexFormat(), "pos", COMP_F32, 2, KEEP_FLOAT);
+		BLI_assert(pos == shdr_pos);
+		UNUSED_VARS_NDEBUG(pos);
+
+		immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
+		is_dashed_shader = false;
 	}
 
-	if (tiny) {
-		setlinestyle(0);
+	if (!tiny) {
+		immUniformColor3fv(curr_col);
+
+		if ((track->pat_flag & SELECT) == sel && (sc->flag & SC_SHOW_MARKER_PATTERN)) {
+			immBegin(PRIM_LINE_LOOP, 4);
+			immVertex2fv(shdr_pos, marker->pattern_corners[0]);
+			immVertex2fv(shdr_pos, marker->pattern_corners[1]);
+			immVertex2fv(shdr_pos, marker->pattern_corners[2]);
+			immVertex2fv(shdr_pos, marker->pattern_corners[3]);
+			immEnd();
+		}
+
+		/* search */
+		show_search = (TRACK_VIEW_SELECTED(sc, track) &&
+		               ((marker->flag & MARKER_DISABLED) == 0 || (sc->flag & SC_SHOW_MARKER_PATTERN) == 0)) != 0;
+
+		if ((track->search_flag & SELECT) == sel && (sc->flag & SC_SHOW_MARKER_SEARCH) && show_search) {
+			imm_draw_line_box(shdr_pos, marker->search_min[0],
+			                            marker->search_min[1],
+			                            marker->search_max[0],
+			                            marker->search_max[1]);
+		}
 	}
 
 	gpuPopMatrix();
@@ -1151,7 +1245,7 @@ static void draw_plane_marker_ex(SpaceClip *sc, Scene *scene, MovieTrackingPlane
 	                       BKE_image_has_ibuf(plane_track->image, NULL);
 	const bool draw_plane_quad = !has_image || plane_track->image_opacity == 0.0f;
 	float px[2];
-	float color[3], selected_color[3];
+	float *curr_color, other_color[3], color[3], selected_color[3];
 
 	px[0] = 1.0f / width / sc->zoom;
 	px[1] = 1.0f / height / sc->zoom;
@@ -1162,67 +1256,144 @@ static void draw_plane_marker_ex(SpaceClip *sc, Scene *scene, MovieTrackingPlane
 	}
 
 	if (draw_plane_quad || is_selected_track) {
-		unsigned int pos = VertexFormat_add_attrib(immVertexFormat(), "pos", COMP_F32, 2, KEEP_FLOAT);
-
-		immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
-
-		if (draw_outline) {
-			immUniformThemeColor(TH_MARKER_OUTLINE);
-		}
-		else {
-			plane_track_colors(is_active_track, color, selected_color);
-
-			immUniformColor3fv(is_selected_track ? selected_color : color);
-		}
+		uint shdr_pos;
+		bool is_uniform_shader_defined = false;
 
 		if (draw_plane_quad) {
 			const bool stipple = !draw_outline && tiny;
 			const bool thick = draw_outline && !tiny;
 
-			if (stipple) {
-				setlinestyle(3);
+			glLineWidth(thick ? 3.0f : 1.0f);
+
+			if (draw_outline) {
+				UI_GetThemeColor3fv(TH_MARKER_OUTLINE, other_color);
+				curr_color = other_color;
+			}
+			else {
+				plane_track_colors(is_active_track, color, selected_color);
+				curr_color = is_selected_track ? selected_color : color;
 			}
 
-			glLineWidth(thick ? 3.0f : 1.0f);
+			if (stipple) {
+				glEnable(GL_BLEND);
+				glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-			/* Draw rectangle itself. */
-			immBegin(PRIM_LINE_LOOP, 4);
-			immVertex2fv(pos, plane_marker->corners[0]);
-			immVertex2fv(pos, plane_marker->corners[1]);
-			immVertex2fv(pos, plane_marker->corners[2]);
-			immVertex2fv(pos, plane_marker->corners[3]);
-			immEnd();
+				VertexFormat *format = immVertexFormat();
+				uint shdr_dashed_pos = VertexFormat_add_attrib(format, "pos", COMP_F32, 2, KEEP_FLOAT);
+				uint shdr_dashed_origin = VertexFormat_add_attrib(format, "line_origin", COMP_F32, 2, KEEP_FLOAT);
 
-			/* Draw axis. */
-			if (!draw_outline) {
-				float end_point[2];
+				immBindBuiltinProgram(GPU_SHADER_2D_LINE_DASHED_COLOR);
 
-				immUniformColor3f(1.0f, 0.0f, 0.0f);
+				float viewport_size[4];
+				glGetFloatv(GL_VIEWPORT, viewport_size);
+				immUniform2f("viewport_size", viewport_size[2] / UI_DPI_FAC, viewport_size[3] / UI_DPI_FAC);
 
-				immBegin(PRIM_LINES, 2);
+				immUniform4f("color1", curr_color[0], curr_color[1], curr_color[2], 1.0f);
+				immUniform4f("color2", 0.0f, 0.0f, 0.0f, 0.0f);
+				immUniform1f("dash_width", 6.0f);
+				immUniform1f("dash_width_on", 3.0f);
 
-				getArrowEndPoint(width, height, sc->zoom, plane_marker->corners[0], plane_marker->corners[1], end_point);
-				immVertex2fv(pos, plane_marker->corners[0]);
-				immVertex2fv(pos, end_point);
+				/* Draw rectangle itself. */
+				immBegin(PRIM_LINES, 8);
+				immAttrib2fv(shdr_dashed_origin, plane_marker->corners[0]);
+				immVertex2fv(shdr_dashed_pos, plane_marker->corners[0]);
+				immVertex2fv(shdr_dashed_pos, plane_marker->corners[1]);
 
+				immAttrib2fv(shdr_dashed_origin, plane_marker->corners[1]);
+				immVertex2fv(shdr_dashed_pos, plane_marker->corners[1]);
+				immVertex2fv(shdr_dashed_pos, plane_marker->corners[2]);
+
+				immAttrib2fv(shdr_dashed_origin, plane_marker->corners[3]);
+				immVertex2fv(shdr_dashed_pos, plane_marker->corners[2]);
+				immVertex2fv(shdr_dashed_pos, plane_marker->corners[3]);
+
+				immAttrib2fv(shdr_dashed_origin, plane_marker->corners[0]);
+				immVertex2fv(shdr_dashed_pos, plane_marker->corners[3]);
+				immVertex2fv(shdr_dashed_pos, plane_marker->corners[0]);
 				immEnd();
 
-				immUniformColor3f(0.0f, 1.0f, 0.0f);
+				/* Draw axis. */
+				if (!draw_outline) {
+					float end_point[2];
 
-				immBegin(PRIM_LINES, 2);
+					immUniform4f("color1", 1.0f, 0.0f, 0.0f, 1.0f);
 
-				getArrowEndPoint(width, height, sc->zoom, plane_marker->corners[0], plane_marker->corners[3], end_point);
-				immVertex2fv(pos, plane_marker->corners[0]);
-				immVertex2fv(pos, end_point);
+					immBegin(PRIM_LINES, 2);
 
-				immEnd();
+					getArrowEndPoint(width, height, sc->zoom, plane_marker->corners[0], plane_marker->corners[1], end_point);
+					immAttrib2fv(shdr_dashed_origin, plane_marker->corners[0]);
+					immVertex2fv(shdr_dashed_pos, plane_marker->corners[0]);
+					immVertex2fv(shdr_dashed_pos, end_point);
+
+					immEnd();
+
+					immUniform4f("color1", 0.0f, 1.0f, 0.0f, 1.0f);
+
+					immBegin(PRIM_LINES, 2);
+
+					getArrowEndPoint(width, height, sc->zoom, plane_marker->corners[0], plane_marker->corners[3], end_point);
+					immAttrib2fv(shdr_dashed_origin, plane_marker->corners[0]);
+					immVertex2fv(shdr_dashed_pos, plane_marker->corners[0]);
+					immVertex2fv(shdr_dashed_pos, end_point);
+
+					immEnd();
+				}
+
+				immUnbindProgram();
+
+				glDisable(GL_BLEND);
 			}
 
-			if (stipple) {
-				setlinestyle(0);
+			shdr_pos = VertexFormat_add_attrib(immVertexFormat(), "pos", COMP_F32, 2, KEEP_FLOAT);
+
+			immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
+			is_uniform_shader_defined = true;
+
+			immUniformColor3fv(curr_color);
+
+			if (!stipple) {
+				/* Draw rectangle itself. */
+				immBegin(PRIM_LINE_LOOP, 4);
+				immVertex2fv(shdr_pos, plane_marker->corners[0]);
+				immVertex2fv(shdr_pos, plane_marker->corners[1]);
+				immVertex2fv(shdr_pos, plane_marker->corners[2]);
+				immVertex2fv(shdr_pos, plane_marker->corners[3]);
+				immEnd();
+
+				/* Draw axis. */
+				if (!draw_outline) {
+					float end_point[2];
+
+					immUniformColor3f(1.0f, 0.0f, 0.0f);
+
+					immBegin(PRIM_LINES, 2);
+
+					getArrowEndPoint(width, height, sc->zoom, plane_marker->corners[0], plane_marker->corners[1], end_point);
+					immVertex2fv(shdr_pos, plane_marker->corners[0]);
+					immVertex2fv(shdr_pos, end_point);
+
+					immEnd();
+
+					immUniformColor3f(0.0f, 1.0f, 0.0f);
+
+					immBegin(PRIM_LINES, 2);
+
+					getArrowEndPoint(width, height, sc->zoom, plane_marker->corners[0], plane_marker->corners[3], end_point);
+					immVertex2fv(shdr_pos, plane_marker->corners[0]);
+					immVertex2fv(shdr_pos, end_point);
+
+					immEnd();
+				}
 			}
 		}
 
+		if (!is_uniform_shader_defined) {
+			shdr_pos = VertexFormat_add_attrib(immVertexFormat(), "pos", COMP_F32, 2, KEEP_FLOAT);
+
+			immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
+			is_uniform_shader_defined = true;
+		}
+
 		/* Draw sliders. */
 		if (is_selected_track) {
 			if (draw_outline) {
@@ -1235,7 +1406,7 @@ static void draw_plane_marker_ex(SpaceClip *sc, Scene *scene, MovieTrackingPlane
 			int i;
 			for (i = 0; i < 4; i++) {
 				draw_marker_slide_square(plane_marker->corners[i][0], plane_marker->corners[i][1],
-										 3.0f * px[0], 3.0f * px[1], draw_outline, px, pos);
+				                         3.0f * px[0], 3.0f * px[1], draw_outline, px, shdr_pos);
 			}
 		}