summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/render/fx_renderer/fx_renderer.h7
-rw-r--r--include/render/fx_renderer/shaders.h67
-rw-r--r--include/scenefx/render/pass.h53
-rw-r--r--render/fx_renderer/fx_pass.c156
-rw-r--r--render/fx_renderer/fx_renderer.c38
-rw-r--r--render/fx_renderer/gles2/shaders/gradient.frag47
-rw-r--r--render/fx_renderer/gles2/shaders/meson.build4
-rw-r--r--render/fx_renderer/gles2/shaders/quad_grad.frag21
-rw-r--r--render/fx_renderer/gles2/shaders/quad_grad_round.frag49
-rw-r--r--render/fx_renderer/gles2/shaders/rounded_grad_border_corner.frag46
-rw-r--r--render/fx_renderer/shaders.c99
11 files changed, 587 insertions, 0 deletions
diff --git a/include/render/fx_renderer/fx_renderer.h b/include/render/fx_renderer/fx_renderer.h
index 526a640..bb8d205 100644
--- a/include/render/fx_renderer/fx_renderer.h
+++ b/include/render/fx_renderer/fx_renderer.h
@@ -161,16 +161,23 @@ struct fx_renderer {
struct {
struct quad_shader quad;
+ struct quad_grad_shader quad_grad;
struct quad_round_shader quad_round;
struct quad_round_shader quad_round_tl;
struct quad_round_shader quad_round_tr;
struct quad_round_shader quad_round_bl;
struct quad_round_shader quad_round_br;
+ struct quad_grad_round_shader quad_grad_round;
+ struct quad_grad_round_shader quad_grad_round_tl;
+ struct quad_grad_round_shader quad_grad_round_tr;
+ struct quad_grad_round_shader quad_grad_round_bl;
+ struct quad_grad_round_shader quad_grad_round_br;
struct tex_shader tex_rgba;
struct tex_shader tex_rgbx;
struct tex_shader tex_ext;
struct box_shadow_shader box_shadow;
struct rounded_border_corner_shader rounded_border_corner;
+ struct rounded_grad_border_corner_shader rounded_grad_border_corner;
struct blur_shader blur1;
struct blur_shader blur2;
struct blur_effects_shader blur_effects;
diff --git a/include/render/fx_renderer/shaders.h b/include/render/fx_renderer/shaders.h
index 6c19744..ad18167 100644
--- a/include/render/fx_renderer/shaders.h
+++ b/include/render/fx_renderer/shaders.h
@@ -37,6 +37,24 @@ struct quad_shader {
bool link_quad_program(struct quad_shader *shader);
+struct quad_grad_shader {
+ int max_len;
+
+ GLuint program;
+ GLint proj;
+ GLint colors;
+ GLint size;
+ GLint degree;
+ GLint grad_box;
+ GLint pos_attrib;
+ GLint linear;
+ GLint origin;
+ GLint count;
+ GLint blend;
+};
+
+bool link_quad_grad_program(struct quad_grad_shader *shader, int max_len);
+
struct quad_round_shader {
GLuint program;
GLint proj;
@@ -49,6 +67,29 @@ struct quad_round_shader {
bool link_quad_round_program(struct quad_round_shader *shader, enum fx_rounded_quad_shader_source source);
+struct quad_grad_round_shader {
+ GLuint program;
+ GLint proj;
+ GLint color;
+ GLint pos_attrib;
+ GLint size;
+ GLint position;
+ GLint radius;
+
+ GLint colors;
+ GLint grad_size;
+ GLint degree;
+ GLint grad_box;
+ GLint linear;
+ GLint origin;
+ GLint count;
+ GLint blend;
+
+ int max_len;
+};
+
+bool link_quad_grad_round_program(struct quad_grad_round_shader *shader, enum fx_rounded_quad_shader_source source, int max_len);
+
struct tex_shader {
GLuint program;
GLint proj;
@@ -84,6 +125,32 @@ struct rounded_border_corner_shader {
bool link_rounded_border_corner_program(struct rounded_border_corner_shader *shader);
+struct rounded_grad_border_corner_shader {
+ int max_len;
+ GLuint program;
+ GLint proj;
+ GLint is_top_left;
+ GLint is_top_right;
+ GLint is_bottom_left;
+ GLint is_bottom_right;
+ GLint position;
+ GLint radius;
+ GLint half_size;
+ GLint half_thickness;
+
+ GLint colors;
+ GLint size;
+ GLint degree;
+ GLint grad_box;
+ GLint pos_attrib;
+ GLint linear;
+ GLint origin;
+ GLint count;
+ GLint blend;
+};
+
+bool link_rounded_grad_border_corner_program(struct rounded_grad_border_corner_shader *shader, int max_len);
+
struct box_shadow_shader {
GLuint program;
GLint proj;
diff --git a/include/scenefx/render/pass.h b/include/scenefx/render/pass.h
index d005c37..0f1d27c 100644
--- a/include/scenefx/render/pass.h
+++ b/include/scenefx/render/pass.h
@@ -27,6 +27,20 @@ struct fx_gles_render_pass *fx_renderer_begin_buffer_pass(struct wlr_renderer *w
struct wlr_buffer *wlr_buffer, struct wlr_output *output,
const struct wlr_buffer_pass_options *options);
+struct fx_gradient {
+ float degree;
+ /* The full area the gradient fit too, for borders use the window size */
+ struct wlr_box range;
+ /* The center of the gradient, {0.5, 0.5} for normal*/
+ float origin[2];
+ /* 1 = Linear, 2 = Conic */
+ int linear;
+ /* Whether or not to blend the colors */
+ int blend;
+ int count;
+ float *colors;
+};
+
struct fx_render_texture_options {
struct wlr_render_texture_options base;
const struct wlr_box *clip_box; // Used to clip csd. Ignored if NULL
@@ -42,6 +56,11 @@ struct fx_render_rect_options {
// TODO: Add effects here in the future
};
+struct fx_render_rect_grad_options {
+ struct wlr_render_rect_options base;
+ struct fx_gradient gradient;
+};
+
struct fx_render_box_shadow_options {
struct wlr_box shadow_box;
struct wlr_box clip_box;
@@ -58,6 +77,13 @@ struct fx_render_rounded_rect_options {
enum corner_location corner_location;
};
+struct fx_render_rounded_rect_grad_options {
+ struct wlr_render_rect_options base;
+ struct fx_gradient gradient;
+ int corner_radius;
+ enum corner_location corner_location;
+};
+
struct fx_render_rounded_border_corner_options {
struct wlr_render_rect_options base;
int corner_radius;
@@ -65,6 +91,14 @@ struct fx_render_rounded_border_corner_options {
enum corner_location corner_location;
};
+struct fx_render_rounded_grad_border_corner_options {
+ struct wlr_render_rect_options base;
+ struct fx_gradient gradient;
+ int corner_radius;
+ int border_thickness;
+ enum corner_location corner_location;
+};
+
struct fx_render_blur_pass_options {
struct fx_render_texture_options tex_options;
pixman_region32_t *opaque_region;
@@ -87,6 +121,12 @@ void fx_render_pass_add_rect(struct fx_gles_render_pass *render_pass,
const struct fx_render_rect_options *options);
/**
+ * Render a rectangle with a gradient.
+ */
+void fx_render_pass_add_rect_grad(struct fx_gles_render_pass *render_pass,
+ const struct fx_render_rect_grad_options *options);
+
+/**
* Render a rounded rectangle.
*/
void fx_render_pass_add_rounded_rect(struct fx_gles_render_pass *render_pass,
@@ -95,10 +135,23 @@ void fx_render_pass_add_rounded_rect(struct fx_gles_render_pass *render_pass,
/**
* Render a border corner.
*/
+void fx_render_pass_add_rounded_rect_grad(struct fx_gles_render_pass *render_pass,
+ const struct fx_render_rounded_rect_grad_options *options);
+
+
+/**
+ * Render a border corner.
+ */
void fx_render_pass_add_rounded_border_corner(struct fx_gles_render_pass *render_pass,
const struct fx_render_rounded_border_corner_options *options);
/**
+ * Render a border corner.
+ */
+void fx_render_pass_add_rounded_grad_border_corner(struct fx_gles_render_pass *render_pass,
+ const struct fx_render_rounded_grad_border_corner_options *options);
+
+/**
* Render a box shadow.
*/
void fx_render_pass_add_box_shadow(struct fx_gles_render_pass *pass,
diff --git a/render/fx_renderer/fx_pass.c b/render/fx_renderer/fx_pass.c
index f0af02b..808d9f4 100644
--- a/render/fx_renderer/fx_pass.c
+++ b/render/fx_renderer/fx_pass.c
@@ -367,6 +367,43 @@ 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) {
+ glDeleteProgram(renderer->shaders.quad_grad.program);
+ 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 +453,76 @@ 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) {
+ glDeleteProgram(shader->program);
+ 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 +557,55 @@ 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) {
+ glDeleteProgram(renderer->shaders.rounded_grad_border_corner.program);
+ 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..3ffc2cd 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, 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_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, 16)) {
+ 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/gradient.frag b/render/fx_renderer/gles2/shaders/gradient.frag
new file mode 100644
index 0000000..0ab6712
--- /dev/null
+++ b/render/fx_renderer/gles2/shaders/gradient.frag
@@ -0,0 +1,47 @@
+#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+vec4 gradient(vec4 colors[LEN], int count, vec2 size, vec2 grad_box, vec2 origin, float degree, bool linear, bool blend){
+ float step;
+
+ vec2 normal = (gl_FragCoord.xy - grad_box)/size;
+ vec2 uv = normal - origin;
+
+ float rad = radians(degree);
+
+ if(linear){
+ uv *= vec2(1.0)/vec2(abs(cos(rad)) + abs(sin(rad)));
+
+ vec2 rotated = vec2(uv.x * cos(rad) - uv.y * sin(rad) + origin.x,
+ uv.x * sin(rad) + uv.y * cos(rad) + origin.y);
+
+ step = rotated.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;
+ }
+
+ if(!blend){
+ float smooth = 1.0/float(count);
+ int ind = int(step/smooth);
+
+ return colors[ind];
+ }
+
+ float smooth = 1.0/float(count - 1);
+ int ind = int(step/smooth);
+ float at = float(ind)*smooth;
+
+ 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;
+}
diff --git a/render/fx_renderer/gles2/shaders/meson.build b/render/fx_renderer/gles2/shaders/meson.build
index f5b5b41..12e4427 100644
--- a/render/fx_renderer/gles2/shaders/meson.build
+++ b/render/fx_renderer/gles2/shaders/meson.build
@@ -2,10 +2,14 @@ embed = find_program('./embed.sh', native: true)
shaders = [
'common.vert',
+ 'gradient.frag',
'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..465da81
--- /dev/null
+++ b/render/fx_renderer/gles2/shaders/quad_grad.frag
@@ -0,0 +1,21 @@
+#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;
+
+void main(){
+ gl_FragColor = gradient(colors, count, size, grad_box, origin, degree, linear, blend);
+}
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..60e5fcf
--- /dev/null
+++ b/render/fx_renderer/gles2/shaders/quad_grad_round.frag
@@ -0,0 +1,49 @@
+#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;
+
+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(colors, count, size, grad_box, origin, degree, linear, blend), 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..9e9aef0
--- /dev/null
+++ b/render/fx_renderer/gles2/shaders/rounded_grad_border_corner.frag
@@ -0,0 +1,46 @@
+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;
+
+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(colors, count, size, grad_box, origin, degree, linear, blend), smoothedAlphaOuter - smoothedAlphaInner);
+}
diff --git a/render/fx_renderer/shaders.c b/render/fx_renderer/shaders.c
index 2c2aa7e..9015510 100644
--- a/render/fx_renderer/shaders.c
+++ b/render/fx_renderer/shaders.c
@@ -8,10 +8,14 @@
// shaders
#include "GLES2/gl2.h"
#include "common_vert_src.h"
+#include "gradient_frag_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"
@@ -114,6 +118,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\n%s", max_len, gradient_frag_src, 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 +166,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\n%s", source, max_len, gradient_frag_src, 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 +248,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\n%s", max_len, gradient_frag_src, 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);
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-10 06:30:46 +0000