add builtin GPU_SHADER_KEYFRAME_DIAMOND

Now we can draw keyframe markers as point sprites, with fewer draw calls and state changes.

Based on the builtin shader for round points with anti-aliased outline. This one is more pointy.

source/blender/gpu/CMakeLists.txt

@@ -185,6 +185,8 @@ data_to_c_simple(shaders/gpu_shader_edges_overlay_simple_geom.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_edges_overlay_frag.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_text_vert.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_text_frag.glsl SRC)
+data_to_c_simple(shaders/gpu_shader_keyframe_diamond_vert.glsl SRC)
+data_to_c_simple(shaders/gpu_shader_keyframe_diamond_frag.glsl SRC)
 
 data_to_c_simple(shaders/gpu_shader_geometry.glsl SRC)
 data_to_c_simple(shaders/gpu_shader_fire_frag.glsl SRC)

source/blender/gpu/GPU_shader.h

@@ -101,6 +101,7 @@ typedef enum GPUBuiltinShader {
 	GPU_SHADER_EDGES_FRONT_BACK_ORTHO,
 	GPU_SHADER_EDGES_OVERLAY_SIMPLE,
 	GPU_SHADER_EDGES_OVERLAY,
+	GPU_SHADER_KEYFRAME_DIAMOND,
 	GPU_SHADER_SIMPLE_LIGHTING,
 	/* for simple 2D drawing */
 	GPU_SHADER_2D_UNIFORM_COLOR,

source/blender/gpu/intern/gpu_shader.c

@@ -102,6 +102,8 @@ extern char datatoc_gpu_shader_edges_overlay_simple_geom_glsl[];
 extern char datatoc_gpu_shader_edges_overlay_frag_glsl[];
 extern char datatoc_gpu_shader_text_vert_glsl[];
 extern char datatoc_gpu_shader_text_frag_glsl[];
+extern char datatoc_gpu_shader_keyframe_diamond_vert_glsl[];
+extern char datatoc_gpu_shader_keyframe_diamond_frag_glsl[];
 
 extern char datatoc_gpu_shader_fire_frag_glsl[];
 extern char datatoc_gpu_shader_smoke_vert_glsl[];
@@ -647,6 +649,8 @@ GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
 		[GPU_SHADER_SMOKE_COBA] = { datatoc_gpu_shader_smoke_vert_glsl, datatoc_gpu_shader_smoke_frag_glsl },
 
 		[GPU_SHADER_TEXT] = { datatoc_gpu_shader_text_vert_glsl, datatoc_gpu_shader_text_frag_glsl },
+		[GPU_SHADER_KEYFRAME_DIAMOND] = { datatoc_gpu_shader_keyframe_diamond_vert_glsl,
+		                                  datatoc_gpu_shader_keyframe_diamond_frag_glsl },
 		[GPU_SHADER_EDGES_FRONT_BACK_PERSP] = { datatoc_gpu_shader_edges_front_back_persp_vert_glsl,
 		        /*  this version is     */      datatoc_gpu_shader_flat_color_frag_glsl,
 		       /*  magical but slooow  */       datatoc_gpu_shader_edges_front_back_persp_geom_glsl },
@@ -668,8 +672,8 @@ 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_IMAGE_INTERLACE] = { datatoc_gpu_shader_2D_image_vert_glsl,
+		                                    datatoc_gpu_shader_image_interlace_frag_glsl },
 		[GPU_SHADER_2D_CHECKER] = { datatoc_gpu_shader_2D_vert_glsl, datatoc_gpu_shader_checker_frag_glsl },
 
 		[GPU_SHADER_2D_UNIFORM_COLOR] = { datatoc_gpu_shader_2D_vert_glsl, datatoc_gpu_shader_uniform_color_frag_glsl },

source/blender/gpu/shaders/gpu_shader_keyframe_diamond_frag.glsl

@@ -0,0 +1,38 @@
+
+#if __VERSION__ == 120
+  varying vec4 radii;
+  varying vec4 finalColor;
+  varying vec4 finalOutlineColor;
+  #define fragColor gl_FragColor
+#else
+  in vec4 radii;
+  in vec4 finalColor;
+  in vec4 finalOutlineColor;
+  out vec4 fragColor;
+#endif
+
+void main() {
+	vec2 quad = abs(gl_PointCoord - vec2(0.5));
+	float dist = quad.x + quad.y;
+
+//	transparent outside of point
+// --- 0 ---
+//	smooth transition
+// --- 1 ---
+//	pure outline color
+// --- 2 ---
+//	smooth transition
+// --- 3 ---
+//	pure point color
+// ...
+// dist = 0 at center of point
+
+	float mid_stroke = 0.5 * (radii[1] + radii[2]);
+
+	vec4 backgroundColor = vec4(finalColor.rgb, 0.0);
+
+	if (dist > mid_stroke)
+		fragColor = mix(finalOutlineColor, backgroundColor, smoothstep(radii[1], radii[0], dist));
+	else
+		fragColor = mix(finalColor, finalOutlineColor, smoothstep(radii[3], radii[2], dist));
+}

source/blender/gpu/shaders/gpu_shader_keyframe_diamond_vert.glsl

@@ -0,0 +1,44 @@
+
+uniform mat4 ModelViewProjectionMatrix;
+
+const float pixel_fudge = sqrt(2.0);
+const float outline_width = 1.25 * pixel_fudge;
+
+#if __VERSION__ == 120
+  attribute vec2 pos;
+  attribute float size;
+  attribute vec4 color;
+  attribute vec4 outlineColor;
+  varying vec4 finalColor;
+  varying vec4 finalOutlineColor;
+  varying vec4 radii;
+#else
+  in vec2 pos;
+  in float size;
+  in vec4 color;
+  in vec4 outlineColor;
+  out vec4 finalColor;
+  out vec4 finalOutlineColor;
+  out vec4 radii;
+#endif
+
+void main() {
+	gl_Position = ModelViewProjectionMatrix * vec4(pos, 0.0, 1.0);
+
+	// pass through unchanged
+	gl_PointSize = size;
+	finalColor = color;
+	finalOutlineColor = outlineColor;
+
+	// calculate concentric radii in pixels
+	float radius = 0.5 * gl_PointSize;
+
+	// start at the outside and progress toward the center
+	radii[0] = radius;
+	radii[1] = radius - pixel_fudge;
+	radii[2] = radius - outline_width;
+	radii[3] = radius - outline_width - pixel_fudge;
+
+	// convert to PointCoord units
+	radii /= size;
+}