add gradient rect support

7 files changed, 521 insertions, 0 deletions

diff --git a/render/fx_renderer/fx_pass.c b/render/fx_renderer/fx_pass.c
index f0af02b..42e0fc7 100644
--- a/render/fx_renderer/fx_pass.c
+++ b/render/fx_renderer/fx_pass.c
@@ -367,6 +367,42 @@ void fx_render_pass_add_rect(struct fx_gles_render_pass *pass,
 	pop_fx_debug(renderer);
 }
 
+void fx_render_pass_add_rect_grad(struct fx_gles_render_pass *pass,
+		const struct fx_render_rect_grad_options *fx_options) {
+	const struct wlr_render_rect_options *options = &fx_options->base;
+
+	struct fx_renderer *renderer = pass->buffer->renderer;
+
+	if(renderer->shaders.quad_grad.max_len <= fx_options->gradient.count){
+		if(!link_quad_grad_program(&renderer->shaders.quad_grad, fx_options->gradient.count + 1)){
+			wlr_log(WLR_ERROR, "Could not link quad shader after updating max_len to %d. Aborting renderer", fx_options->gradient.count + 1);
+			abort();
+		}
+	}
+
+	struct wlr_box box;
+	wlr_render_rect_options_get_box(options, pass->buffer->buffer, &box);
+
+	push_fx_debug(renderer);
+	setup_blending(options->blend_mode);
+
+	glUseProgram(renderer->shaders.quad_grad.program);
+
+	set_proj_matrix(renderer->shaders.quad_grad.proj, pass->projection_matrix, &box);
+	glUniform4fv(renderer->shaders.quad_grad.colors, fx_options->gradient.count, (GLfloat*)fx_options->gradient.colors);
+	glUniform1i(renderer->shaders.quad_grad.count, fx_options->gradient.count);
+	glUniform2f(renderer->shaders.quad_grad.size, fx_options->gradient.range.width, fx_options->gradient.range.height);
+	glUniform1f(renderer->shaders.quad_grad.degree, fx_options->gradient.degree);
+	glUniform1f(renderer->shaders.quad_grad.linear, fx_options->gradient.linear);
+	glUniform1f(renderer->shaders.quad_grad.blend, fx_options->gradient.blend);
+	glUniform2f(renderer->shaders.quad_grad.grad_box, fx_options->gradient.range.x, fx_options->gradient.range.y);
+	glUniform2f(renderer->shaders.quad_grad.origin, fx_options->gradient.origin[0], fx_options->gradient.origin[1]);
+
+	render(&box, options->clip, renderer->shaders.quad_grad.pos_attrib);
+
+	pop_fx_debug(renderer);
+}
+
 void fx_render_pass_add_rounded_rect(struct fx_gles_render_pass *pass,
 		const struct fx_render_rounded_rect_options *fx_options) {
 	const struct wlr_render_rect_options *options = &fx_options->base;
@@ -416,6 +452,75 @@ void fx_render_pass_add_rounded_rect(struct fx_gles_render_pass *pass,
 	pop_fx_debug(renderer);
 }
 
+void fx_render_pass_add_rounded_rect_grad(struct fx_gles_render_pass *pass,
+		const struct fx_render_rounded_rect_grad_options *fx_options) {
+	const struct wlr_render_rect_options *options = &fx_options->base;
+
+	struct fx_renderer *renderer = pass->buffer->renderer;
+
+	struct quad_grad_round_shader *shader = NULL;
+	enum fx_rounded_quad_shader_source corner;
+	switch (fx_options->corner_location) {
+	case ALL:
+		corner = SHADER_SOURCE_QUAD_ROUND;
+		shader = &renderer->shaders.quad_grad_round;
+		break;
+	case TOP_LEFT:
+		corner = SHADER_SOURCE_QUAD_ROUND_TOP_LEFT;
+		shader = &renderer->shaders.quad_grad_round_tl;
+		break;
+	case TOP_RIGHT:
+		corner = SHADER_SOURCE_QUAD_ROUND_TOP_RIGHT;
+		shader = &renderer->shaders.quad_grad_round_tr;
+		break;
+	case BOTTOM_LEFT:
+		corner = SHADER_SOURCE_QUAD_ROUND_BOTTOM_LEFT;
+		shader = &renderer->shaders.quad_grad_round_bl;
+		break;
+	case BOTTOM_RIGHT:
+		corner = SHADER_SOURCE_QUAD_ROUND_TOP_RIGHT;
+		shader = &renderer->shaders.quad_grad_round_br;
+		break;
+	default:
+		wlr_log(WLR_ERROR, "Invalid Corner Location. Aborting render");
+		abort();
+	}
+
+	if(shader->max_len <= fx_options->gradient.count){
+		if(!link_quad_grad_round_program(shader, corner, fx_options->gradient.count + 1)){
+			wlr_log(WLR_ERROR, "Could not link quad shader after updating max_len to %d. Aborting renderer", fx_options->gradient.count + 1);
+			abort();
+		}
+	}
+
+	struct wlr_box box;
+	wlr_render_rect_options_get_box(options, pass->buffer->buffer, &box);
+
+	push_fx_debug(renderer);
+	setup_blending(WLR_RENDER_BLEND_MODE_PREMULTIPLIED);
+
+	glUseProgram(shader->program);
+
+	set_proj_matrix(shader->proj, pass->projection_matrix, &box);
+
+	glUniform2f(shader->size, box.width, box.height);
+	glUniform2f(shader->position, box.x, box.y);
+	glUniform1f(shader->radius, fx_options->corner_radius);
+
+	glUniform4fv(shader->colors, fx_options->gradient.count, (GLfloat*)fx_options->gradient.colors);
+	glUniform1i(shader->count, fx_options->gradient.count);
+	glUniform2f(shader->grad_size, fx_options->gradient.range.width, fx_options->gradient.range.height);
+	glUniform1f(shader->degree, fx_options->gradient.degree);
+	glUniform1f(shader->linear, fx_options->gradient.linear);
+	glUniform1f(shader->blend, fx_options->gradient.blend);
+	glUniform2f(shader->grad_box, fx_options->gradient.range.x, fx_options->gradient.range.y);
+	glUniform2f(shader->origin, fx_options->gradient.origin[0], fx_options->gradient.origin[1]);
+
+	render(&box, options->clip, shader->pos_attrib);
+
+	pop_fx_debug(renderer);
+}
+
 void fx_render_pass_add_rounded_border_corner(struct fx_gles_render_pass *pass,
 		const struct fx_render_rounded_border_corner_options *fx_options) {
 	const struct wlr_render_rect_options *options = &fx_options->base;
@@ -450,6 +555,54 @@ void fx_render_pass_add_rounded_border_corner(struct fx_gles_render_pass *pass,
 	pop_fx_debug(renderer);
 }
 
+void fx_render_pass_add_rounded_grad_border_corner(struct fx_gles_render_pass *pass,
+		const struct fx_render_rounded_grad_border_corner_options *fx_options) {
+	const struct wlr_render_rect_options *options = &fx_options->base;
+
+	struct fx_renderer *renderer = pass->buffer->renderer;
+
+	if(renderer->shaders.rounded_grad_border_corner.max_len <= fx_options->gradient.count){
+		if(!link_rounded_grad_border_corner_program(&renderer->shaders.rounded_grad_border_corner, fx_options->gradient.count + 1)){
+			wlr_log(WLR_ERROR, "Could not link quad shader after updating max_len to %d. Aborting renderer", fx_options->gradient.count + 1);
+			abort();
+		}
+	}
+
+	struct wlr_box box;
+	wlr_render_rect_options_get_box(options, pass->buffer->buffer, &box);
+	assert(box.width > 0 && box.width == box.height); // should be a perfect square since we are drawing a circle
+
+	push_fx_debug(renderer);
+	setup_blending(WLR_RENDER_BLEND_MODE_PREMULTIPLIED);
+
+	glUseProgram(renderer->shaders.rounded_grad_border_corner.program);
+
+	set_proj_matrix(renderer->shaders.rounded_grad_border_corner.proj, pass->projection_matrix, &box);
+
+	glUniform1f(renderer->shaders.rounded_grad_border_corner.is_top_left, fx_options->corner_location == TOP_LEFT);
+	glUniform1f(renderer->shaders.rounded_grad_border_corner.is_top_right, fx_options->corner_location == TOP_RIGHT);
+	glUniform1f(renderer->shaders.rounded_grad_border_corner.is_bottom_left, fx_options->corner_location == BOTTOM_LEFT);
+	glUniform1f(renderer->shaders.rounded_grad_border_corner.is_bottom_right, fx_options->corner_location == BOTTOM_RIGHT);
+
+	glUniform2f(renderer->shaders.rounded_grad_border_corner.position, box.x, box.y);
+	glUniform1f(renderer->shaders.rounded_grad_border_corner.radius, fx_options->corner_radius);
+	glUniform2f(renderer->shaders.rounded_grad_border_corner.half_size, box.width / 2.0, box.height / 2.0);
+	glUniform1f(renderer->shaders.rounded_grad_border_corner.half_thickness, fx_options->border_thickness / 2.0);
+
+	glUniform4fv(renderer->shaders.rounded_grad_border_corner.colors, fx_options->gradient.count, (GLfloat*)fx_options->gradient.colors);
+	glUniform1i(renderer->shaders.rounded_grad_border_corner.count, fx_options->gradient.count);
+	glUniform2f(renderer->shaders.rounded_grad_border_corner.size, fx_options->gradient.range.width, fx_options->gradient.range.height);
+	glUniform1f(renderer->shaders.rounded_grad_border_corner.degree, fx_options->gradient.degree);
+	glUniform1f(renderer->shaders.rounded_grad_border_corner.linear, fx_options->gradient.linear);
+	glUniform1f(renderer->shaders.rounded_grad_border_corner.blend, fx_options->gradient.blend);
+	glUniform2f(renderer->shaders.rounded_grad_border_corner.grad_box, fx_options->gradient.range.x, fx_options->gradient.range.y);
+	glUniform2f(renderer->shaders.rounded_grad_border_corner.origin, fx_options->gradient.origin[0], fx_options->gradient.origin[1]);
+
+	render(&box, options->clip, renderer->shaders.rounded_grad_border_corner.pos_attrib);
+
+	pop_fx_debug(renderer);
+}
+
 void fx_render_pass_add_box_shadow(struct fx_gles_render_pass *pass,
 		const struct fx_render_box_shadow_options *options) {
 	struct fx_renderer *renderer = pass->buffer->renderer;
diff --git a/render/fx_renderer/fx_renderer.c b/render/fx_renderer/fx_renderer.c
index d2ab366..9c22868 100644
--- a/render/fx_renderer/fx_renderer.c
+++ b/render/fx_renderer/fx_renderer.c
@@ -639,6 +639,38 @@ static bool link_shaders(struct fx_renderer *renderer) {
 		goto error;
 	}
 
+	// quad fragment shader with gradients
+	if (!link_quad_grad_program(&renderer->shaders.quad_grad, 16)) {
+		wlr_log(WLR_ERROR, "Could not link quad shader");
+		goto error;
+	}
+
+	// rounded quad fragment shaders
+	if (!link_quad_grad_round_program(&renderer->shaders.quad_grad_round, SHADER_SOURCE_QUAD_ROUND, 16)) {
+		wlr_log(WLR_ERROR, "Could not link quad shader");
+		goto error;
+	}
+	// rounded quad fragment shaders
+	if (!link_quad_grad_round_program(&renderer->shaders.quad_grad_round_tl, SHADER_SOURCE_QUAD_ROUND_TOP_LEFT, 2)) {
+		wlr_log(WLR_ERROR, "Could not link quad shader");
+		goto error;
+	}
+	// rounded quad fragment shaders
+	if (!link_quad_grad_round_program(&renderer->shaders.quad_grad_round_tr, SHADER_SOURCE_QUAD_ROUND_TOP_RIGHT, 16)) {
+		wlr_log(WLR_ERROR, "Could not link quad shader");
+		goto error;
+	}
+	// rounded quad fragment shaders
+	if (!link_quad_grad_round_program(&renderer->shaders.quad_grad_round_bl, SHADER_SOURCE_QUAD_ROUND_BOTTOM_LEFT, 16)) {
+		wlr_log(WLR_ERROR, "Could not link quad shader");
+		goto error;
+	}
+	// rounded quad fragment shaders
+	if (!link_quad_grad_round_program(&renderer->shaders.quad_grad_round_br, SHADER_SOURCE_QUAD_ROUND_BOTTOM_RIGHT, 16)) {
+		wlr_log(WLR_ERROR, "Could not link quad shader");
+		goto error;
+	}
+
 	// rounded quad fragment shaders
 	if (!link_quad_round_program(&renderer->shaders.quad_round, SHADER_SOURCE_QUAD_ROUND)) {
 		wlr_log(WLR_ERROR, "Could not link quad shader");
@@ -685,6 +717,12 @@ static bool link_shaders(struct fx_renderer *renderer) {
 		goto error;
 	}
 
+	// border corner shader with gradients
+	if (!link_rounded_grad_border_corner_program(&renderer->shaders.rounded_grad_border_corner, 2)) {
+		wlr_log(WLR_ERROR, "Could not link quad shader");
+		goto error;
+	}
+
 	// box shadow shader
 	if (!link_box_shadow_program(&renderer->shaders.box_shadow)) {
 		wlr_log(WLR_ERROR, "Could not link box shadow shader");
diff --git a/render/fx_renderer/gles2/shaders/meson.build b/render/fx_renderer/gles2/shaders/meson.build
index f5b5b41..ce08097 100644
--- a/render/fx_renderer/gles2/shaders/meson.build
+++ b/render/fx_renderer/gles2/shaders/meson.build
@@ -3,9 +3,12 @@ embed = find_program('./embed.sh', native: true)
 shaders = [
     'common.vert',
     'quad.frag',
+    'quad_grad.frag',
     'quad_round.frag',
+    'quad_grad_round.frag',
     'tex.frag',
     'rounded_border_corner.frag',
+    'rounded_grad_border_corner.frag',
     'box_shadow.frag',
     'blur1.frag',
     'blur2.frag',
diff --git a/render/fx_renderer/gles2/shaders/quad_grad.frag b/render/fx_renderer/gles2/shaders/quad_grad.frag
new file mode 100644
index 0000000..d259942
--- /dev/null
+++ b/render/fx_renderer/gles2/shaders/quad_grad.frag
@@ -0,0 +1,57 @@
+#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+uniform vec4 colors[LEN];
+uniform vec2 size;
+uniform float degree;
+uniform vec2 grad_box;
+uniform vec2 origin;
+uniform bool linear;
+uniform bool blend;
+uniform int count;
+
+vec4 gradient(){
+	float step;
+
+	vec2 normal = (gl_FragCoord.xy - grad_box)/size;
+	vec2 uv = normal - origin;
+
+	float rad = radians(degree);
+
+	if(linear){
+		float angle = rad + atan(uv.x, uv.y);
+
+		float len = length(uv);
+		uv = vec2(cos(angle) * len, sin(angle) * len) + origin;
+		step = uv.x;
+	} else {
+		vec2 uv = normal - origin;
+		uv = vec2(uv.x * cos(rad) - uv.y * sin(rad),
+				uv.x * sin(rad) + uv.y * cos(rad));
+
+		uv = vec2(-atan(uv.y, uv.x)/3.14159265 * 0.5 + 0.5, 0.0);
+		step = uv.x;
+	}
+
+	float smooth = 1.0/float(count - 1);
+    int ind = int(step/smooth);
+    float at = float(ind)*smooth;
+
+	if(!blend) return colors[ind];
+
+    vec4 color = colors[ind];
+    if(ind > 0) color = mix(colors[ind - 1], color, smoothstep(at - smooth, at, step));
+    if(ind <= count - 1) color = mix(color, colors[ind + 1], smoothstep(at, at + smooth, step));
+
+	return color;
+}
+
+void main(){
+	gl_FragColor = gradient();
+}
diff --git a/render/fx_renderer/gles2/shaders/quad_grad_round.frag b/render/fx_renderer/gles2/shaders/quad_grad_round.frag
new file mode 100644
index 0000000..58cdb53
--- /dev/null
+++ b/render/fx_renderer/gles2/shaders/quad_grad_round.frag
@@ -0,0 +1,84 @@
+#define SOURCE_QUAD_ROUND 1
+#define SOURCE_QUAD_ROUND_TOP_LEFT 2
+#define SOURCE_QUAD_ROUND_TOP_RIGHT 3
+#define SOURCE_QUAD_ROUND_BOTTOM_RIGHT 4
+#define SOURCE_QUAD_ROUND_BOTTOM_LEFT 5
+
+#if !defined(SOURCE)
+#error "Missing shader preamble"
+#endif
+
+precision mediump float;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+uniform vec2 size;
+uniform vec2 position;
+uniform float radius;
+
+uniform vec4 colors[LEN];
+uniform vec2 grad_size;
+uniform float degree;
+uniform vec2 grad_box;
+uniform vec2 origin;
+uniform bool linear;
+uniform bool blend;
+uniform int count;
+
+vec4 gradient(){
+	float step;
+
+	vec2 normal = (gl_FragCoord.xy - grad_box)/grad_size;
+	vec2 uv = normal - origin;
+
+	float rad = radians(degree);
+
+	if(linear){
+		float angle = rad + atan(uv.x, uv.y);
+
+		float len = length(uv);
+		uv = vec2(cos(angle) * len, sin(angle) * len) + origin;
+		step = uv.x;
+	} else {
+		vec2 uv = normal - origin;
+		uv = vec2(uv.x * cos(rad) - uv.y * sin(rad),
+				uv.x * sin(rad) + uv.y * cos(rad));
+
+		uv = vec2(-atan(uv.y, uv.x)/3.14159265 * 0.5 + 0.5, 0.0);
+		step = uv.x;
+	}
+
+	float smooth = 1.0/float(count - 1);
+    int ind = int(step/smooth);
+    float at = float(ind)*smooth;
+
+	if(!blend) return colors[ind];
+
+    vec4 color = colors[ind];
+    if(ind > 0) color = mix(colors[ind - 1], color, smoothstep(at - smooth, at, step));
+    if(ind <= count - 1) color = mix(color, colors[ind + 1], smoothstep(at, at + smooth, step));
+
+	return color;
+}
+
+vec2 getCornerDist() {
+#if SOURCE == SOURCE_QUAD_ROUND
+    vec2 half_size = size * 0.5;
+    return abs(gl_FragCoord.xy - position - half_size) - half_size + radius;
+#elif SOURCE == SOURCE_QUAD_ROUND_TOP_LEFT
+    return abs(gl_FragCoord.xy - position - size) - size + radius;
+#elif SOURCE == SOURCE_QUAD_ROUND_TOP_RIGHT
+    return abs(gl_FragCoord.xy - position - vec2(0, size.y)) - size + radius;
+#elif SOURCE == SOURCE_QUAD_ROUND_BOTTOM_RIGHT
+    return abs(gl_FragCoord.xy - position) - size + radius;
+#elif SOURCE == SOURCE_QUAD_ROUND_BOTTOM_LEFT
+    return abs(gl_FragCoord.xy - position - vec2(size.x, 0)) - size + radius;
+#endif
+}
+
+void main() {
+    vec2 q = getCornerDist();
+    float dist = min(max(q.x,q.y), 0.0) + length(max(q, 0.0)) - radius;
+    float smoothedAlpha = 1.0 - smoothstep(-1.0, 0.5, dist);
+    gl_FragColor = mix(vec4(0), gradient(), smoothedAlpha);
+}
diff --git a/render/fx_renderer/gles2/shaders/rounded_grad_border_corner.frag b/render/fx_renderer/gles2/shaders/rounded_grad_border_corner.frag
new file mode 100644
index 0000000..ef36f06
--- /dev/null
+++ b/render/fx_renderer/gles2/shaders/rounded_grad_border_corner.frag
@@ -0,0 +1,82 @@
+precision mediump float;
+varying vec4 v_color;
+varying vec2 v_texcoord;
+
+uniform bool is_top_left;
+uniform bool is_top_right;
+uniform bool is_bottom_left;
+uniform bool is_bottom_right;
+
+uniform vec2 position;
+uniform float radius;
+uniform vec2 half_size;
+uniform float half_thickness;
+
+uniform vec4 colors[LEN];
+uniform vec2 size;
+uniform float degree;
+uniform vec2 grad_box;
+uniform vec2 origin;
+uniform bool linear;
+uniform bool blend;
+uniform int count;
+
+vec4 gradient(){
+	float step;
+
+	vec2 normal = (gl_FragCoord.xy - grad_box)/size;
+	vec2 uv = normal - origin;
+
+	float rad = radians(degree);
+
+	if(linear){
+		float angle = rad + atan(uv.x, uv.y);
+
+		float len = length(uv);
+		uv = vec2(cos(angle) * len, sin(angle) * len) + origin;
+		step = uv.x;
+	} else {
+		vec2 uv = normal - origin;
+		uv = vec2(uv.x * cos(rad) - uv.y * sin(rad),
+				uv.x * sin(rad) + uv.y * cos(rad));
+
+		uv = vec2(-atan(uv.y, uv.x)/3.14159265 * 0.5 + 0.5, 0.0);
+		step = uv.x;
+	}
+
+	float smooth = 1.0/float(count - 1);
+    int ind = int(step/smooth);
+    float at = float(ind)*smooth;
+
+	if(!blend) return colors[ind];
+
+    vec4 color = colors[ind];
+    if(ind > 0) color = mix(colors[ind - 1], color, smoothstep(at - smooth, at, step));
+    if(ind <= count - 1) color = mix(color, colors[ind + 1], smoothstep(at, at + smooth, step));
+
+	return color;
+}
+
+float roundedBoxSDF(vec2 center, vec2 size, float radius) {
+    return length(max(abs(center) - size + radius, 0.0)) - radius;
+}
+
+void main() {
+    vec2 center = gl_FragCoord.xy - position - half_size;
+    float distance = roundedBoxSDF(center, half_size - half_thickness, radius + half_thickness);
+    float smoothedAlphaOuter = 1.0 - smoothstep(-1.0, 1.0, distance - half_thickness);
+    // Create an inner circle that isn't as anti-aliased as the outer ring
+    float smoothedAlphaInner = 1.0 - smoothstep(-1.0, 0.5, distance + half_thickness);
+
+    if (is_top_left && (center.y > 0.0 || center.x > 0.0)) {
+        discard;
+    } else if (is_top_right && (center.y > 0.0 || center.x < 0.0)) {
+        discard;
+    } else if (is_bottom_left && (center.y < 0.0 || center.x > 0.0)) {
+        discard;
+    } else if (is_bottom_right && (center.y < 0.0 || center.x < 0.0)) {
+        discard;
+    }
+
+    gl_FragColor = mix(vec4(0), gradient(), smoothedAlphaOuter - smoothedAlphaInner);
+}
diff --git a/render/fx_renderer/shaders.c b/render/fx_renderer/shaders.c
index 2c2aa7e..21cd522 100644
--- a/render/fx_renderer/shaders.c
+++ b/render/fx_renderer/shaders.c
@@ -9,9 +9,12 @@
 #include "GLES2/gl2.h"
 #include "common_vert_src.h"
 #include "quad_frag_src.h"
+#include "quad_grad_frag_src.h"
 #include "quad_round_frag_src.h"
+#include "quad_grad_round_frag_src.h"
 #include "tex_frag_src.h"
 #include "rounded_border_corner_frag_src.h"
+#include "rounded_grad_border_corner_frag_src.h"
 #include "box_shadow_frag_src.h"
 #include "blur1_frag_src.h"
 #include "blur2_frag_src.h"
@@ -26,6 +29,12 @@ GLuint compile_shader(GLuint type, const GLchar *src) {
 	glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
 	if (ok == GL_FALSE) {
 		wlr_log(WLR_ERROR, "Failed to compile shader");
+		GLint maxLength = 0;
+		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
+
+		char a[maxLength];
+		glGetShaderInfoLog(shader, maxLength, &maxLength, a);
+		printf("%s\n", a);
 		glDeleteShader(shader);
 		shader = 0;
 	}
@@ -114,6 +123,33 @@ bool link_quad_program(struct quad_shader *shader) {
 	return true;
 }
 
+bool link_quad_grad_program(struct quad_grad_shader *shader, int max_len) {
+	GLchar quad_src[2048];
+	snprintf(quad_src, sizeof(quad_src),
+			"#define LEN %d\n%s", max_len, quad_grad_frag_src);
+
+	GLuint prog;
+	shader->program = prog = link_program(quad_src);
+	if (!shader->program) {
+		return false;
+	}
+
+	shader->proj = glGetUniformLocation(prog, "proj");
+	shader->pos_attrib = glGetAttribLocation(prog, "pos");
+	shader->size = glGetUniformLocation(prog, "size");
+	shader->colors = glGetUniformLocation(prog, "colors");
+	shader->degree = glGetUniformLocation(prog, "degree");
+	shader->grad_box = glGetUniformLocation(prog, "grad_box");
+	shader->linear = glGetUniformLocation(prog, "linear");
+	shader->origin = glGetUniformLocation(prog, "origin");
+	shader->count = glGetUniformLocation(prog, "count");
+	shader->blend = glGetUniformLocation(prog, "blend");
+
+	shader->max_len = max_len;
+
+	return true;
+}
+
 bool link_quad_round_program(struct quad_round_shader *shader, enum fx_rounded_quad_shader_source source) {
 	GLchar quad_src[2048];
 	snprintf(quad_src, sizeof(quad_src),
@@ -135,6 +171,38 @@ bool link_quad_round_program(struct quad_round_shader *shader, enum fx_rounded_q
 	return true;
 }
 
+bool link_quad_grad_round_program(struct quad_grad_round_shader *shader, enum fx_rounded_quad_shader_source source, int max_len) {
+	GLchar quad_src[4096];
+	snprintf(quad_src, sizeof(quad_src),
+		"#define SOURCE %d\n#define LEN %d\n%s", source, max_len, quad_grad_round_frag_src);
+
+	GLuint prog;
+	shader->program = prog = link_program(quad_src);
+	if (!shader->program) {
+		return false;
+	}
+
+	shader->proj = glGetUniformLocation(prog, "proj");
+	shader->color = glGetUniformLocation(prog, "color");
+	shader->pos_attrib = glGetAttribLocation(prog, "pos");
+	shader->size = glGetUniformLocation(prog, "size");
+	shader->position = glGetUniformLocation(prog, "position");
+	shader->radius = glGetUniformLocation(prog, "radius");
+
+	shader->grad_size = glGetUniformLocation(prog, "grad_size");
+	shader->colors = glGetUniformLocation(prog, "colors");
+	shader->degree = glGetUniformLocation(prog, "degree");
+	shader->grad_box = glGetUniformLocation(prog, "grad_box");
+	shader->linear = glGetUniformLocation(prog, "linear");
+	shader->origin = glGetUniformLocation(prog, "origin");
+	shader->count = glGetUniformLocation(prog, "count");
+	shader->blend = glGetUniformLocation(prog, "blend");
+
+	shader->max_len = max_len;
+
+	return true;
+}
+
 bool link_tex_program(struct tex_shader *shader,
 		enum fx_tex_shader_source source) {
 	GLchar frag_src[2048];
@@ -185,6 +253,42 @@ bool link_rounded_border_corner_program(struct rounded_border_corner_shader *sha
 	return true;
 }
 
+bool link_rounded_grad_border_corner_program(struct rounded_grad_border_corner_shader *shader, int max_len) {
+	GLchar quad_src[4096];
+	snprintf(quad_src, sizeof(quad_src),
+			"#define LEN %d\n%s", max_len, rounded_grad_border_corner_frag_src);
+
+	GLuint prog;
+	shader->program = prog = link_program(quad_src);
+	if (!shader->program) {
+		return false;
+	}
+
+	shader->proj = glGetUniformLocation(prog, "proj");
+	shader->pos_attrib = glGetAttribLocation(prog, "pos");
+	shader->size = glGetUniformLocation(prog, "size");
+	shader->colors = glGetUniformLocation(prog, "colors");
+	shader->degree = glGetUniformLocation(prog, "degree");
+	shader->grad_box = glGetUniformLocation(prog, "grad_box");
+	shader->linear = glGetUniformLocation(prog, "linear");
+	shader->origin = glGetUniformLocation(prog, "origin");
+	shader->count = glGetUniformLocation(prog, "count");
+	shader->blend = glGetUniformLocation(prog, "blend");
+
+	shader->is_top_left = glGetUniformLocation(prog, "is_top_left");
+	shader->is_top_right = glGetUniformLocation(prog, "is_top_right");
+	shader->is_bottom_left = glGetUniformLocation(prog, "is_bottom_left");
+	shader->is_bottom_right = glGetUniformLocation(prog, "is_bottom_right");
+	shader->position = glGetUniformLocation(prog, "position");
+	shader->radius = glGetUniformLocation(prog, "radius");
+	shader->half_size = glGetUniformLocation(prog, "half_size");
+	shader->half_thickness = glGetUniformLocation(prog, "half_thickness");
+
+	shader->max_len = max_len;
+
+	return true;
+}
+
 bool link_box_shadow_program(struct box_shadow_shader *shader) {
 	GLuint prog;
 	shader->program = prog = link_program(box_shadow_frag_src);