[Glamor] [V2 PATCH 1/6] Extract the logic of gradient from the glamor_render.c to the file glamor_gradient.c, modify pixmap gl draw and kill warnings
He Junyan
junyan.he at linux.intel.com
Tue May 15 03:21:13 PDT 2012
+ /* Swap the vtx for triangle render. */
+ tmp = vertices[4];
+ vertices[4] = vertices[6];
+ vertices[6] = tmp;
+ tmp = vertices[5];
+ vertices[5] = vertices[7];
+ vertices[7] = tmp;
+
+ tmp = tex_vertices[4];
+ tex_vertices[4] = tex_vertices[6];
+ tex_vertices[6] = tmp;
+ tmp = tex_vertices[5];
+ tex_vertices[5] = tex_vertices[7];
+ tex_vertices[7] = tmp;
> Maybe you can write a new macro to do the vertices calculating and get
> correct vertices sequence for Trangle_Strip and thus can avoid this
> vertices swapping.
Yeah, it should be a macro.
I will do it later, and if modify here, the patch of this serial is hard
to rebase.
> From: Junyan He<junyan.he at linux.intel.com>
>
> 1.Extract the logic of gradient from the glamor_render.c
> to the file glamor_gradient.c. 2.Modify the logic of
> gradient pixmap gl draw. Use the logic like composite
> before, but the gradient always just have one rect to
> render, so no need to set the VB and EB, replace it
> with just call glDrawArrays. 3.Kill all the warning in
> glamor_render.c
>
>
> Signed-off-by: Junyan He<junyan.he at linux.intel.com>
> ---
> src/Makefile.am | 1 +
> src/glamor_gradient.c | 1633 +++++++++++++++++++++++++++++++++++++++++++++++++
> src/glamor_priv.h | 13 +-
> src/glamor_render.c | 1587 +-----------------------------------------------
> 4 files changed, 1653 insertions(+), 1581 deletions(-)
> create mode 100644 src/glamor_gradient.c
>
> diff --git a/src/Makefile.am b/src/Makefile.am
> index 8e334b1..2e94ffd 100644
> --- a/src/Makefile.am
> +++ b/src/Makefile.am
> @@ -33,6 +33,7 @@ libglamor_la_SOURCES = \
> glamor_putimage.c \
> glamor_setspans.c \
> glamor_render.c \
> + glamor_gradient.c \
> glamor_tile.c \
> glamor_triangles.c\
> glamor_addtraps.c\
> diff --git a/src/glamor_gradient.c b/src/glamor_gradient.c
> new file mode 100644
> index 0000000..f6b635f
> --- /dev/null
> +++ b/src/glamor_gradient.c
> @@ -0,0 +1,1633 @@
> +/*
> + * Copyright © 2009 Intel Corporation
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the "Software"),
> + * to deal in the Software without restriction, including without limitation
> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> + * and/or sell copies of the Software, and to permit persons to whom the
> + * Software is furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice (including the next
> + * paragraph) shall be included in all copies or substantial portions of the
> + * Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
> + * IN THE SOFTWARE.
> + *
> + * Authors:
> + * Junyan He<junyan.he at linux.intel.com>
> + *
> + */
> +
> +/** @file glamor_gradient.c
> + *
> + * Gradient acceleration implementation
> + */
> +
> +#include "glamor_priv.h"
> +
> +#ifdef RENDER
> +
> +#define LINEAR_SMALL_STOPS 6 + 2
> +#define LINEAR_LARGE_STOPS 16 + 2
> +
> +#define RADIAL_SMALL_STOPS 6 + 2
> +#define RADIAL_LARGE_STOPS 16 + 2
> +
> +#ifdef GLAMOR_GRADIENT_SHADER
> +
> +static GLint
> +_glamor_create_getcolor_fs_program(ScreenPtr screen, int stops_count, int use_array)
> +{
> + glamor_screen_private *glamor_priv;
> + glamor_gl_dispatch *dispatch;
> +
> + char *gradient_fs = NULL;
> + GLint fs_getcolor_prog;
> +
> + const char *gradient_fs_getcolor =
> + GLAMOR_DEFAULT_PRECISION
> + "uniform int n_stop;\n"
> + "uniform float stops[%d];\n"
> + "uniform vec4 stop_colors[%d];\n"
> + "vec4 get_color(float stop_len)\n"
> + "{\n"
> + " int i = 0;\n"
> + " float new_alpha; \n"
> + " vec4 gradient_color;\n"
> + " float percentage; \n"
> + " for(i = 0; i< n_stop - 1; i++) {\n"
> + " if(stop_len< stops[i])\n"
> + " break; \n"
> + " }\n"
> + " \n"
> + " percentage = (stop_len - stops[i-1])/(stops[i] - stops[i-1]);\n"
> + " if(stops[i] - stops[i-1]> 2.0)\n"
> + " percentage = 0.0;\n" //For comply with pixman, walker->stepper overflow.
> + " new_alpha = percentage * stop_colors[i].a + \n"
> + " (1.0-percentage) * stop_colors[i-1].a; \n"
> + " gradient_color = vec4((percentage * stop_colors[i].rgb \n"
> + " + (1.0-percentage) * stop_colors[i-1].rgb)*new_alpha, \n"
> + " new_alpha);\n"
> + " \n"
> + " return gradient_color;\n"
> + "}\n";
> +
> + /* Because the array access for shader is very slow, the performance is very low
> + if use array. So use global uniform to replace for it if the number of n_stops is small.*/
> + const char *gradient_fs_getcolor_no_array =
> + GLAMOR_DEFAULT_PRECISION
> + "uniform int n_stop;\n"
> + "uniform float stop0;\n"
> + "uniform float stop1;\n"
> + "uniform float stop2;\n"
> + "uniform float stop3;\n"
> + "uniform float stop4;\n"
> + "uniform float stop5;\n"
> + "uniform float stop6;\n"
> + "uniform float stop7;\n"
> + "uniform vec4 stop_color0;\n"
> + "uniform vec4 stop_color1;\n"
> + "uniform vec4 stop_color2;\n"
> + "uniform vec4 stop_color3;\n"
> + "uniform vec4 stop_color4;\n"
> + "uniform vec4 stop_color5;\n"
> + "uniform vec4 stop_color6;\n"
> + "uniform vec4 stop_color7;\n"
> + "\n"
> + "vec4 get_color(float stop_len)\n"
> + "{\n"
> + " float stop_after;\n"
> + " float stop_before;\n"
> + " vec4 stop_color_before;\n"
> + " vec4 stop_color_after;\n"
> + " float new_alpha; \n"
> + " vec4 gradient_color;\n"
> + " float percentage; \n"
> + " \n"
> + " if((stop_len< stop0)&& (n_stop>= 1)) {\n"
> + " stop_color_before = stop_color0;\n"
> + " stop_color_after = stop_color0;\n"
> + " stop_after = stop0;\n"
> + " stop_before = stop0;\n"
> + " percentage = 0.0;\n"
> + " } else if((stop_len< stop1)&& (n_stop>= 2)) {\n"
> + " stop_color_before = stop_color0;\n"
> + " stop_color_after = stop_color1;\n"
> + " stop_after = stop1;\n"
> + " stop_before = stop0;\n"
> + " percentage = (stop_len - stop0)/(stop1 - stop0);\n"
> + " } else if((stop_len< stop2)&& (n_stop>= 3)) {\n"
> + " stop_color_before = stop_color1;\n"
> + " stop_color_after = stop_color2;\n"
> + " stop_after = stop2;\n"
> + " stop_before = stop1;\n"
> + " percentage = (stop_len - stop1)/(stop2 - stop1);\n"
> + " } else if((stop_len< stop3)&& (n_stop>= 4)){\n"
> + " stop_color_before = stop_color2;\n"
> + " stop_color_after = stop_color3;\n"
> + " stop_after = stop3;\n"
> + " stop_before = stop2;\n"
> + " percentage = (stop_len - stop2)/(stop3 - stop2);\n"
> + " } else if((stop_len< stop4)&& (n_stop>= 5)){\n"
> + " stop_color_before = stop_color3;\n"
> + " stop_color_after = stop_color4;\n"
> + " stop_after = stop4;\n"
> + " stop_before = stop3;\n"
> + " percentage = (stop_len - stop3)/(stop4 - stop3);\n"
> + " } else if((stop_len< stop5)&& (n_stop>= 6)){\n"
> + " stop_color_before = stop_color4;\n"
> + " stop_color_after = stop_color5;\n"
> + " stop_after = stop5;\n"
> + " stop_before = stop4;\n"
> + " percentage = (stop_len - stop4)/(stop5 - stop4);\n"
> + " } else if((stop_len< stop6)&& (n_stop>= 7)){\n"
> + " stop_color_before = stop_color5;\n"
> + " stop_color_after = stop_color6;\n"
> + " stop_after = stop6;\n"
> + " stop_before = stop5;\n"
> + " percentage = (stop_len - stop5)/(stop6 - stop5);\n"
> + " } else if((stop_len< stop7)&& (n_stop>= 8)){\n"
> + " stop_color_before = stop_color6;\n"
> + " stop_color_after = stop_color7;\n"
> + " stop_after = stop7;\n"
> + " stop_before = stop6;\n"
> + " percentage = (stop_len - stop6)/(stop7 - stop6);\n"
> + " } else {\n"
> + " stop_color_before = stop_color7;\n"
> + " stop_color_after = stop_color7;\n"
> + " stop_after = stop7;\n"
> + " stop_before = stop7;\n"
> + " percentage = 0.0;\n"
> + " }\n"
> + " if(stop_after - stop_before> 2.0)\n"
> + " percentage = 0.0;\n"//For comply with pixman, walker->stepper overflow.
> + " new_alpha = percentage * stop_color_after.a + \n"
> + " (1.0-percentage) * stop_color_before.a; \n"
> + " gradient_color = vec4((percentage * stop_color_after.rgb \n"
> + " + (1.0-percentage) * stop_color_before.rgb)*new_alpha, \n"
> + " new_alpha);\n"
> + " \n"
> + " return gradient_color;\n"
> + "}\n";
> +
> + glamor_priv = glamor_get_screen_private(screen);
> + dispatch = glamor_get_dispatch(glamor_priv);
> +
> + if(use_array) {
> + XNFasprintf(&gradient_fs,
> + gradient_fs_getcolor, stops_count, stops_count);
> + fs_getcolor_prog = glamor_compile_glsl_prog(dispatch, GL_FRAGMENT_SHADER,
> + gradient_fs);
> + free(gradient_fs);
> + } else {
> + fs_getcolor_prog = glamor_compile_glsl_prog(dispatch, GL_FRAGMENT_SHADER,
> + gradient_fs_getcolor_no_array);
> + }
> +
> + return fs_getcolor_prog;
> +}
> +
> +static void
> +_glamor_create_radial_gradient_program(ScreenPtr screen, int stops_count, int dyn_gen)
> +{
> + glamor_screen_private *glamor_priv;
> + glamor_gl_dispatch *dispatch;
> + int index;
> +
> + GLint gradient_prog = 0;
> + char *gradient_fs = NULL;
> + GLint fs_main_prog, fs_getcolor_prog, vs_prog;
> +
> + const char *gradient_vs =
> + GLAMOR_DEFAULT_PRECISION
> + "attribute vec4 v_position;\n"
> + "attribute vec4 v_texcoord;\n"
> + "varying vec2 source_texture;\n"
> + "\n"
> + "void main()\n"
> + "{\n"
> + " gl_Position = v_position;\n"
> + " source_texture = v_texcoord.xy;\n"
> + "}\n";
> +
> + /*
> + * Refer to pixman radial gradient.
> + *
> + * The problem is given the two circles of c1 and c2 with the radius of r1 and
> + * r1, we need to caculate the t, which is used to do interpolate with stops,
> + * using the fomula:
> + * length((1-t)*c1 + t*c2 - p) = (1-t)*r1 + t*r2
> + * expand the fomula with xy coond, get the following:
> + * sqrt(sqr((1-t)*c1.x + t*c2.x - p.x) + sqr((1-t)*c1.y + t*c2.y - p.y))
> + * = (1-t)r1 + t*r2
> + *<====> At*t- 2Bt + C = 0
> + * where A = sqr(c2.x - c1.x) + sqr(c2.y - c1.y) - sqr(r2 -r1)
> + * B = (p.x - c1.x)*(c2.x - c1.x) + (p.y - c1.y)*(c2.y - c1.y) + r1*(r2 -r1)
> + * C = sqr(p.x - c1.x) + sqr(p.y - c1.y) - r1*r1
> + *
> + * solve the fomula and we get the result of
> + * t = (B + sqrt(B*B - A*C)) / A or
> + * t = (B - sqrt(B*B - A*C)) / A (quadratic equation have two solutions)
> + *
> + * The solution we are going to prefer is the bigger one, unless the
> + * radius associated to it is negative (or it falls outside the valid t range)
> + */
> +
> + const char *gradient_fs_template =
> + GLAMOR_DEFAULT_PRECISION
> + "uniform mat3 transform_mat;\n"
> + "uniform int repeat_type;\n"
> + "uniform float A_value;\n"
> + "uniform vec2 c1;\n"
> + "uniform float r1;\n"
> + "uniform vec2 c2;\n"
> + "uniform float r2;\n"
> + "varying vec2 source_texture;\n"
> + "\n"
> + "vec4 get_color(float stop_len);\n"
> + "\n"
> + "int t_invalid;\n"
> + "\n"
> + "float get_stop_len()\n"
> + "{\n"
> + " float t = 0.0;\n"
> + " float sqrt_value;\n"
> + " int revserse = 0;\n"
> + " t_invalid = 0;\n"
> + " \n"
> + " vec3 tmp = vec3(source_texture.x, source_texture.y, 1.0);\n"
> + " vec3 source_texture_trans = transform_mat * tmp;\n"
> + " source_texture_trans.xy = source_texture_trans.xy/source_texture_trans.z;\n"
> + " float B_value = (source_texture_trans.x - c1.x) * (c2.x - c1.x)\n"
> + " + (source_texture_trans.y - c1.y) * (c2.y - c1.y)\n"
> + " + r1 * (r2 - r1);\n"
> + " float C_value = (source_texture_trans.x - c1.x) * (source_texture_trans.x - c1.x)\n"
> + " + (source_texture_trans.y - c1.y) * (source_texture_trans.y - c1.y)\n"
> + " - r1*r1;\n"
> + " if(abs(A_value)< 0.00001) {\n"
> + " if(B_value == 0.0) {\n"
> + " t_invalid = 1;\n"
> + " return t;\n"
> + " }\n"
> + " t = 0.5 * C_value / B_value;"
> + " } else {\n"
> + " sqrt_value = B_value * B_value - A_value * C_value;\n"
> + " if(sqrt_value< 0.0) {\n"
> + " t_invalid = 1;\n"
> + " return t;\n"
> + " }\n"
> + " sqrt_value = sqrt(sqrt_value);\n"
> + " t = (B_value + sqrt_value) / A_value;\n"
> + " }\n"
> + " if(repeat_type == %d) {\n" // RepeatNone case.
> + " if((t<= 0.0) || (t> 1.0))\n"
> + // try another if first one invalid
> + " t = (B_value - sqrt_value) / A_value;\n"
> + " \n"
> + " if((t<= 0.0) || (t> 1.0)) {\n" //still invalid, return.
> + " t_invalid = 1;\n"
> + " return t;\n"
> + " }\n"
> + " } else {\n"
> + " if(t * (r2 - r1)<= -1.0 * r1)\n"
> + // try another if first one invalid
> + " t = (B_value - sqrt_value) / A_value;\n"
> + " \n"
> + " if(t * (r2 -r1)<= -1.0 * r1) {\n" //still invalid, return.
> + " t_invalid = 1;\n"
> + " return t;\n"
> + " }\n"
> + " }\n"
> + " \n"
> + " if(repeat_type == %d){\n" // repeat normal
> + " while(t> 1.0) \n"
> + " t = t - 1.0; \n"
> + " while(t< 0.0) \n"
> + " t = t + 1.0; \n"
> + " }\n"
> + " \n"
> + " if(repeat_type == %d) {\n" // repeat reflect
> + " while(t> 1.0) {\n"
> + " t = t - 1.0; \n"
> + " if(revserse == 0)\n"
> + " revserse = 1;\n"
> + " else\n"
> + " revserse = 0;\n"
> + " }\n"
> + " while(t< 0.0) {\n"
> + " t = t + 1.0; \n"
> + " if(revserse == 0)\n"
> + " revserse = 1;\n"
> + " else\n"
> + " revserse = 0;\n"
> + " }\n"
> + " if(revserse == 1) {\n"
> + " t = 1.0 - t; \n"
> + " }\n"
> + " }\n"
> + " \n"
> + " return t;\n"
> + "}\n"
> + "\n"
> + "void main()\n"
> + "{\n"
> + " float stop_len = get_stop_len();\n"
> + " if(t_invalid == 1) {\n"
> + " gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);\n"
> + " } else {\n"
> + " gl_FragColor = get_color(stop_len);\n"
> + " }\n"
> + "}\n";
> +
> + glamor_priv = glamor_get_screen_private(screen);
> +
> + if ((glamor_priv->radial_max_nstops>= stops_count)&& (dyn_gen)) {
> + /* Very Good, not to generate again. */
> + return;
> + }
> +
> + dispatch = glamor_get_dispatch(glamor_priv);
> +
> + if (dyn_gen&& glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][2]) {
> + dispatch->glDeleteShader(
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_VS_PROG][2]);
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_VS_PROG][2] = 0;
> +
> + dispatch->glDeleteShader(
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][2]);
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][2] = 0;
> +
> + dispatch->glDeleteShader(
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][2]);
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][2] = 0;
> +
> + dispatch->glDeleteProgram(glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][2]);
> + glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][2] = 0;
> + }
> +
> + gradient_prog = dispatch->glCreateProgram();
> +
> + vs_prog = glamor_compile_glsl_prog(dispatch,
> + GL_VERTEX_SHADER, gradient_vs);
> +
> + XNFasprintf(&gradient_fs,
> + gradient_fs_template,
> + PIXMAN_REPEAT_NONE, PIXMAN_REPEAT_NORMAL, PIXMAN_REPEAT_REFLECT);
> +
> + fs_main_prog = glamor_compile_glsl_prog(dispatch,
> + GL_FRAGMENT_SHADER, gradient_fs);
> +
> + free(gradient_fs);
> +
> + fs_getcolor_prog =
> + _glamor_create_getcolor_fs_program(screen, stops_count, (stops_count> 0));
> +
> + dispatch->glAttachShader(gradient_prog, vs_prog);
> + dispatch->glAttachShader(gradient_prog, fs_getcolor_prog);
> + dispatch->glAttachShader(gradient_prog, fs_main_prog);
> +
> + dispatch->glBindAttribLocation(gradient_prog, GLAMOR_VERTEX_POS, "v_positionsition");
> + dispatch->glBindAttribLocation(gradient_prog, GLAMOR_VERTEX_SOURCE, "v_texcoord");
> +
> + glamor_link_glsl_prog(dispatch, gradient_prog);
> +
> + dispatch->glUseProgram(0);
> +
> + if (dyn_gen) {
> + index = 2;
> + glamor_priv->radial_max_nstops = stops_count;
> + } else if (stops_count) {
> + index = 1;
> + } else {
> + index = 0;
> + }
> +
> + glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][index] = gradient_prog;
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_VS_PROG][index] = vs_prog;
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][index] = fs_main_prog;
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][index] = fs_getcolor_prog;
> +
> + glamor_put_dispatch(glamor_priv);
> +}
> +
> +static void
> +_glamor_create_linear_gradient_program(ScreenPtr screen, int stops_count, int dyn_gen)
> +{
> + glamor_screen_private *glamor_priv;
> + glamor_gl_dispatch *dispatch;
> +
> + int index = 0;
> + GLint gradient_prog = 0;
> + char *gradient_fs = NULL;
> + GLint fs_main_prog, fs_getcolor_prog, vs_prog;
> +
> + const char *gradient_vs =
> + GLAMOR_DEFAULT_PRECISION
> + "attribute vec4 v_position;\n"
> + "attribute vec4 v_texcoord;\n"
> + "varying vec2 source_texture;\n"
> + "\n"
> + "void main()\n"
> + "{\n"
> + " gl_Position = v_position;\n"
> + " source_texture = v_texcoord.xy;\n"
> + "}\n";
> +
> + /*
> + * |
> + * |\
> + * | \
> + * | \
> + * | \
> + * |\ \
> + * | \ \
> + * cos_val = |\ p1d \ /
> + * sqrt(1/(slope*slope+1.0)) ------>\ \ \ /
> + * | \ \ \
> + * | \ \ / \
> + * | \ *Pt1\
> + * *p1 | \ \ *P
> + * \ | / \ \ /
> + * \ | / \ \ /
> + * \ | pd \
> + * \ | \ / \
> + * p2* | \ / \ /
> + * slope = (p2.y - p1.y) / | / p2d /
> + * (p2.x - p1.x) | / \ /
> + * | / \ /
> + * | / /
> + * | / /
> + * | / *Pt2
> + * | /
> + * | /
> + * | /
> + * | /
> + * | /
> + * -------+---------------------------------
> + * O|
> + * |
> + * |
> + *
> + * step 1: compute the distance of p, pt1 and pt2 in the slope direction.
> + * Caculate the distance on Y axis first and multiply cos_val to
> + * get the value on slope direction(pd, p1d and p2d represent the
> + * distance of p, pt1, and pt2 respectively).
> + *
> + * step 2: caculate the percentage of (pd - p1d)/(p2d - p1d).
> + * If (pd - p1d)> (p2d - p1d) or< 0, then sub or add (p2d - p1d)
> + * to make it in the range of [0, (p2d - p1d)].
> + *
> + * step 3: compare the percentage to every stop and find the stpos just
> + * before and after it. Use the interpolation fomula to compute RGBA.
> + */
> +
> + const char *gradient_fs_template =
> + GLAMOR_DEFAULT_PRECISION
> + "uniform mat3 transform_mat;\n"
> + "uniform int repeat_type;\n"
> + "uniform int hor_ver;\n"
> + "uniform vec4 pt1;\n"
> + "uniform vec4 pt2;\n"
> + "uniform float pt_slope;\n"
> + "uniform float cos_val;\n"
> + "uniform float p1_distance;\n"
> + "uniform float pt_distance;\n"
> + "varying vec2 source_texture;\n"
> + "\n"
> + "vec4 get_color(float stop_len);\n"
> + "\n"
> + "float get_stop_len()\n"
> + "{\n"
> + " vec3 tmp = vec3(source_texture.x, source_texture.y, 1.0);\n"
> + " float len_percentage;\n"
> + " float distance;\n"
> + " float _p1_distance;\n"
> + " float _pt_distance;\n"
> + " float y_dist;\n"
> + " float stop_after;\n"
> + " float stop_before;\n"
> + " vec4 stop_color_before;\n"
> + " vec4 stop_color_after;\n"
> + " float new_alpha; \n"
> + " int revserse = 0;\n"
> + " vec4 gradient_color;\n"
> + " float percentage; \n"
> + " vec3 source_texture_trans = transform_mat * tmp;\n"
> + " \n"
> + " if(hor_ver == 0) { \n" //Normal case.
> + " y_dist = source_texture_trans.y - source_texture_trans.x*pt_slope;\n"
> + " distance = y_dist * cos_val;\n"
> + " _p1_distance = p1_distance * source_texture_trans.z;\n"
> + " _pt_distance = pt_distance * source_texture_trans.z;\n"
> + " \n"
> + " } else if (hor_ver == 1) {\n"//horizontal case.
> + " distance = source_texture_trans.x;\n"
> + " _p1_distance = p1_distance * source_texture_trans.z;\n"
> + " _pt_distance = pt_distance * source_texture_trans.z;\n"
> + " } else if (hor_ver == 2) {\n"//vertical case.
> + " distance = source_texture_trans.y;\n"
> + " _p1_distance = p1_distance * source_texture_trans.z;\n"
> + " _pt_distance = pt_distance * source_texture_trans.z;\n"
> + " } \n"
> + " \n"
> + " distance = distance - _p1_distance; \n"
> + " \n"
> + " if(repeat_type == %d){\n" // repeat normal
> + " while(distance> _pt_distance) \n"
> + " distance = distance - (_pt_distance); \n"
> + " while(distance< 0.0) \n"
> + " distance = distance + (_pt_distance); \n"
> + " }\n"
> + " \n"
> + " if(repeat_type == %d) {\n" // repeat reflect
> + " while(distance> _pt_distance) {\n"
> + " distance = distance - (_pt_distance); \n"
> + " if(revserse == 0)\n"
> + " revserse = 1;\n"
> + " else\n"
> + " revserse = 0;\n"
> + " }\n"
> + " while(distance< 0.0) {\n"
> + " distance = distance + (_pt_distance); \n"
> + " if(revserse == 0)\n"
> + " revserse = 1;\n"
> + " else\n"
> + " revserse = 0;\n"
> + " }\n"
> + " if(revserse == 1) {\n"
> + " distance = (_pt_distance) - distance; \n"
> + " }\n"
> + " }\n"
> + " \n"
> + " len_percentage = distance/(_pt_distance);\n"
> + " \n"
> + " return len_percentage;\n"
> + "}\n"
> + "\n"
> + "void main()\n"
> + "{\n"
> + " float stop_len = get_stop_len();\n"
> + " gl_FragColor = get_color(stop_len);\n"
> + "}\n";
> +
> +
> + glamor_priv = glamor_get_screen_private(screen);
> +
> + if ((glamor_priv->linear_max_nstops>= stops_count)&& (dyn_gen)) {
> + /* Very Good, not to generate again. */
> + return;
> + }
> +
> + dispatch = glamor_get_dispatch(glamor_priv);
> + if (dyn_gen&& glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][2]) {
> + dispatch->glDeleteShader(
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_VS_PROG][2]);
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_VS_PROG][2] = 0;
> +
> + dispatch->glDeleteShader(
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][2]);
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][2] = 0;
> +
> + dispatch->glDeleteShader(
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][2]);
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][2] = 0;
> +
> + dispatch->glDeleteProgram(glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][2]);
> + glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][2] = 0;
> + }
> +
> + gradient_prog = dispatch->glCreateProgram();
> +
> + vs_prog = glamor_compile_glsl_prog(dispatch,
> + GL_VERTEX_SHADER, gradient_vs);
> +
> + XNFasprintf(&gradient_fs,
> + gradient_fs_template,
> + PIXMAN_REPEAT_NORMAL, PIXMAN_REPEAT_REFLECT);
> +
> + fs_main_prog = glamor_compile_glsl_prog(dispatch,
> + GL_FRAGMENT_SHADER, gradient_fs);
> + free(gradient_fs);
> +
> + fs_getcolor_prog =
> + _glamor_create_getcolor_fs_program(screen, stops_count, (stops_count> 0));
> +
> + dispatch->glAttachShader(gradient_prog, vs_prog);
> + dispatch->glAttachShader(gradient_prog, fs_getcolor_prog);
> + dispatch->glAttachShader(gradient_prog, fs_main_prog);
> +
> + dispatch->glBindAttribLocation(gradient_prog, GLAMOR_VERTEX_POS, "v_position");
> + dispatch->glBindAttribLocation(gradient_prog, GLAMOR_VERTEX_SOURCE, "v_texcoord");
> +
> + glamor_link_glsl_prog(dispatch, gradient_prog);
> +
> + dispatch->glUseProgram(0);
> +
> + if (dyn_gen) {
> + index = 2;
> + glamor_priv->linear_max_nstops = stops_count;
> + } else if (stops_count) {
> + index = 1;
> + } else {
> + index = 0;
> + }
> +
> + glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][index] = gradient_prog;
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_VS_PROG][index] = vs_prog;
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][index] = fs_main_prog;
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][index] = fs_getcolor_prog;
> +
> + glamor_put_dispatch(glamor_priv);
> +}
> +
> +void
> +glamor_init_gradient_shader(ScreenPtr screen)
> +{
> + glamor_screen_private *glamor_priv;
> + int i;
> +
> + glamor_priv = glamor_get_screen_private(screen);
> +
> + for (i = 0; i< 3; i++) {
> + glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][i] = 0;
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_VS_PROG][i] = 0;
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][i] = 0;
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][i] = 0;
> +
> + glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][i] = 0;
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_VS_PROG][i] = 0;
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][i] = 0;
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][i] = 0;
> + }
> + glamor_priv->linear_max_nstops = 0;
> + glamor_priv->radial_max_nstops = 0;
> +
> + _glamor_create_linear_gradient_program(screen, 0, 0);
> + _glamor_create_linear_gradient_program(screen, LINEAR_LARGE_STOPS, 0);
> +
> + _glamor_create_radial_gradient_program(screen, 0, 0);
> + _glamor_create_radial_gradient_program(screen, RADIAL_LARGE_STOPS, 0);
> +}
> +
> +void
> +glamor_fini_gradient_shader(ScreenPtr screen)
> +{
> + glamor_screen_private *glamor_priv;
> + glamor_gl_dispatch *dispatch;
> + int i = 0;
> +
> + glamor_priv = glamor_get_screen_private(screen);
> + dispatch = glamor_get_dispatch(glamor_priv);
> +
> + for (i = 0; i< 3; i++) {
> + /* Linear Gradient */
> + if (glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_VS_PROG][i])
> + dispatch->glDeleteShader(
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_VS_PROG][i]);
> +
> + if (glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][i])
> + dispatch->glDeleteShader(
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][i]);
> +
> + if (glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][i])
> + dispatch->glDeleteShader(
> + glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][i]);
> +
> + if (glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][i])
> + dispatch->glDeleteProgram(glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][i]);
> +
> + /* Radial Gradient */
> + if (glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_VS_PROG][i])
> + dispatch->glDeleteShader(
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_VS_PROG][i]);
> +
> + if (glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][i])
> + dispatch->glDeleteShader(
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][i]);
> +
> + if (glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][i])
> + dispatch->glDeleteShader(
> + glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][i]);
> +
> + if (glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][i])
> + dispatch->glDeleteProgram(glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][i]);
> + }
> +
> + glamor_put_dispatch(glamor_priv);
> +}
> +
> +static void
> +_glamor_gradient_convert_trans_matrix(PictTransform *from, float to[3][3],
> + int width, int height, int normalize)
> +{
> + /*
> + * Because in the shader program, we normalize all the pixel cood to [0, 1],
> + * so with the transform matrix, the correct logic should be:
> + * v_s = A*T*v
> + * v_s: point vector in shader after normalized.
> + * A: The transition matrix from width X height --> 1.0 X 1.0
> + * T: The transform matrix.
> + * v: point vector in width X height space.
> + *
> + * result is OK if we use this fomula. But for every point in width X height space,
> + * we can just use their normalized point vector in shader, namely we can just
> + * use the result of A*v in shader. So we have no chance to insert T in A*v.
> + * We can just convert v_s = A*T*v to v_s = A*T*inv(A)*A*v, where inv(A) is the
> + * inverse matrix of A. Now, v_s = (A*T*inv(A)) * (A*v)
> + * So, to get the correct v_s, we need to cacula1 the matrix: (A*T*inv(A)), and
> + * we name this matrix T_s.
> + *
> + * Firstly, because A is for the scale convertion, we find
> + * -- --
> + * |1/w 0 0 |
> + * A = | 0 1/h 0 |
> + * | 0 0 1.0|
> + * -- --
> + * so T_s = A*T*inv(a) and result
> + *
> + * -- --
> + * | t11 h*t12/w t13/w|
> + * T_s = | w*t21/h t22 t23/h|
> + * | w*t31 h*t32 t33 |
> + * -- --
> + */
> +
> + to[0][0] = (float)pixman_fixed_to_double(from->matrix[0][0]);
> + to[0][1] = (float)pixman_fixed_to_double(from->matrix[0][1])
> + * (normalize ? (((float)height) / ((float)width)) : 1.0);
> + to[0][2] = (float)pixman_fixed_to_double(from->matrix[0][2])
> + / (normalize ? ((float)width) : 1.0);
> +
> + to[1][0] = (float)pixman_fixed_to_double(from->matrix[1][0])
> + * (normalize ? (((float)width) / ((float)height)) : 1.0);
> + to[1][1] = (float)pixman_fixed_to_double(from->matrix[1][1]);
> + to[1][2] = (float)pixman_fixed_to_double(from->matrix[1][2])
> + / (normalize ? ((float)height) : 1.0);
> +
> + to[2][0] = (float)pixman_fixed_to_double(from->matrix[2][0])
> + * (normalize ? ((float)width) : 1.0);
> + to[2][1] = (float)pixman_fixed_to_double(from->matrix[2][1])
> + * (normalize ? ((float)height) : 1.0);
> + to[2][2] = (float)pixman_fixed_to_double(from->matrix[2][2]);
> +
> + DEBUGF("the transform matrix is:\n%f\t%f\t%f\n%f\t%f\t%f\n%f\t%f\t%f\n",
> + to[0][0], to[0][1], to[0][2],
> + to[1][0], to[1][1], to[1][2],
> + to[2][0], to[2][1], to[2][2]);
> +}
> +
> +static int
> +_glamor_gradient_set_pixmap_destination(ScreenPtr screen,
> + glamor_screen_private *glamor_priv,
> + PicturePtr dst_picture,
> + GLfloat *xscale, GLfloat *yscale,
> + int x_source, int y_source,
> + float vertices[8],
> + float tex_vertices[8],
> + int tex_normalize)
> +{
> + glamor_pixmap_private *pixmap_priv;
> + PixmapPtr pixmap = NULL;
> + glamor_gl_dispatch *dispatch = NULL;
> + float tmp;
> +
> + pixmap = glamor_get_drawable_pixmap(dst_picture->pDrawable);
> + pixmap_priv = glamor_get_pixmap_private(pixmap);
> +
> + if (!GLAMOR_PIXMAP_PRIV_HAS_FBO(pixmap_priv)) { /* should always have here. */
> + return 0;
> + }
> +
> + glamor_set_destination_pixmap_priv_nc(pixmap_priv);
> +
> + pixmap_priv_get_scale(pixmap_priv, xscale, yscale);
> +
> + DEBUGF("xscale = %f, yscale = %f,"
> + " x_source = %d, y_source = %d, width = %d, height = %d\n",
> + *xscale, *yscale, x_source, y_source,
> + dst_picture->pDrawable->width, dst_picture->pDrawable->height);
> +
> + glamor_set_normalize_vcoords(*xscale, *yscale,
> + 0, 0,
> + (INT16)(dst_picture->pDrawable->width),
> + (INT16)(dst_picture->pDrawable->height),
> + glamor_priv->yInverted, vertices);
> +
> + if (tex_normalize) {
> + glamor_set_normalize_tcoords(*xscale, *yscale,
> + 0, 0,
> + (INT16)(dst_picture->pDrawable->width),
> + (INT16)(dst_picture->pDrawable->height),
> + glamor_priv->yInverted, tex_vertices);
> + } else {
> + glamor_set_tcoords(0, 0,
> + (INT16)(dst_picture->pDrawable->width),
> + (INT16)(dst_picture->pDrawable->height),
> + glamor_priv->yInverted, tex_vertices);
> + }
> +
> + DEBUGF("vertices --> leftup : %f X %f, rightup: %f X %f,"
> + "rightbottom: %f X %f, leftbottom : %f X %f\n",
> + vertices[0], vertices[1], vertices[2], vertices[3],
> + vertices[4], vertices[5], vertices[6], vertices[7]);
> + DEBUGF("tex_vertices --> leftup : %f X %f, rightup: %f X %f,"
> + "rightbottom: %f X %f, leftbottom : %f X %f\n",
> + tex_vertices[0], tex_vertices[1], tex_vertices[2], tex_vertices[3],
> + tex_vertices[4], tex_vertices[5], tex_vertices[6], tex_vertices[7]);
> +
> + /* Swap the vtx for triangle render. */
> + tmp = vertices[4];
> + vertices[4] = vertices[6];
> + vertices[6] = tmp;
> + tmp = vertices[5];
> + vertices[5] = vertices[7];
> + vertices[7] = tmp;
> +
> + tmp = tex_vertices[4];
> + tex_vertices[4] = tex_vertices[6];
> + tex_vertices[6] = tmp;
> + tmp = tex_vertices[5];
> + tex_vertices[5] = tex_vertices[7];
> + tex_vertices[7] = tmp;
> +
> + dispatch = glamor_get_dispatch(glamor_priv);
> +
> + dispatch->glVertexAttribPointer(GLAMOR_VERTEX_POS, 2, GL_FLOAT,
> + GL_FALSE, 0, vertices);
> + dispatch->glVertexAttribPointer(GLAMOR_VERTEX_SOURCE, 2, GL_FLOAT,
> + GL_FALSE, 0, tex_vertices);
> +
> + dispatch->glEnableVertexAttribArray(GLAMOR_VERTEX_POS);
> + dispatch->glEnableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
> +
> + glamor_put_dispatch(glamor_priv);
> +
> + return 1;
> +}
> +
> +static int
> +_glamor_gradient_set_stops(PicturePtr src_picture, PictGradient * pgradient,
> + GLfloat *stop_colors, GLfloat *n_stops)
> +{
> + int i;
> + int count = 1;
> +
> + for (i = 0; i< pgradient->nstops; i++) {
> + /* We find some gradient picture set the stops at the same percentage, which
> + will cause the shader problem because the (stops[i] - stops[i-1]) will
> + be used as divisor. We just keep the later one if stops[i] == stops[i-1] */
> + if (i< pgradient->nstops - 1
> + && pgradient->stops[i].x == pgradient->stops[i+1].x)
> + continue;
> +
> + stop_colors[count*4] = pixman_fixed_to_double(
> + pgradient->stops[i].color.red);
> + stop_colors[count*4+1] = pixman_fixed_to_double(
> + pgradient->stops[i].color.green);
> + stop_colors[count*4+2] = pixman_fixed_to_double(
> + pgradient->stops[i].color.blue);
> + stop_colors[count*4+3] = pixman_fixed_to_double(
> + pgradient->stops[i].color.alpha);
> +
> + n_stops[count] = (GLfloat)pixman_fixed_to_double(
> + pgradient->stops[i].x);
> + count++;
> + }
> +
> + /* for the end stop. */
> + count++;
> +
> + switch (src_picture->repeatType) {
> +#define REPEAT_FILL_STOPS(m, n) \
> + stop_colors[(m)*4 + 0] = stop_colors[(n)*4 + 0]; \
> + stop_colors[(m)*4 + 1] = stop_colors[(n)*4 + 1]; \
> + stop_colors[(m)*4 + 2] = stop_colors[(n)*4 + 2]; \
> + stop_colors[(m)*4 + 3] = stop_colors[(n)*4 + 3];
> +
> + default:
> + case PIXMAN_REPEAT_NONE:
> + stop_colors[0] = 0.0; //R
> + stop_colors[1] = 0.0; //G
> + stop_colors[2] = 0.0; //B
> + stop_colors[3] = 0.0; //Alpha
> + n_stops[0] = -(float)INT_MAX; //should be small enough.
> +
> + stop_colors[0 + (count-1)*4] = 0.0; //R
> + stop_colors[1 + (count-1)*4] = 0.0; //G
> + stop_colors[2 + (count-1)*4] = 0.0; //B
> + stop_colors[3 + (count-1)*4] = 0.0; //Alpha
> + n_stops[count-1] = (float)INT_MAX; //should be large enough.
> + break;
> + case PIXMAN_REPEAT_NORMAL:
> + REPEAT_FILL_STOPS(0, count - 2);
> + n_stops[0] = n_stops[count-2] - 1.0;
> +
> + REPEAT_FILL_STOPS(count - 1, 1);
> + n_stops[count-1] = n_stops[1] + 1.0;
> + break;
> + case PIXMAN_REPEAT_REFLECT:
> + REPEAT_FILL_STOPS(0, 1);
> + n_stops[0] = -n_stops[1];
> +
> + REPEAT_FILL_STOPS(count - 1, count - 2);
> + n_stops[count-1] = 1.0 + 1.0 - n_stops[count-2];
> + break;
> + case PIXMAN_REPEAT_PAD:
> + REPEAT_FILL_STOPS(0, 1);
> + n_stops[0] = -(float)INT_MAX;
> +
> + REPEAT_FILL_STOPS(count - 1, count - 2);
> + n_stops[count-1] = (float)INT_MAX;
> + break;
> +#undef REPEAT_FILL_STOPS
> + }
> +
> + for (i = 0; i< count; i++) {
> + DEBUGF("n_stops[%d] = %f, color = r:%f g:%f b:%f a:%f\n",
> + i, n_stops[i],
> + stop_colors[i*4], stop_colors[i*4+1],
> + stop_colors[i*4+2], stop_colors[i*4+3]);
> + }
> +
> + return count;
> +}
> +
> +PicturePtr
> +glamor_generate_radial_gradient_picture(ScreenPtr screen,
> + PicturePtr src_picture,
> + int x_source, int y_source,
> + int width, int height,
> + PictFormatShort format)
> +{
> + glamor_screen_private *glamor_priv;
> + glamor_gl_dispatch *dispatch;
> + PicturePtr dst_picture = NULL;
> + PixmapPtr pixmap = NULL;
> + GLint gradient_prog = 0;
> + int error;
> + float tex_vertices[8];
> + int stops_count = 0;
> + int count = 0;
> + GLfloat *stop_colors = NULL;
> + GLfloat *n_stops = NULL;
> + GLfloat xscale, yscale;
> + float vertices[8];
> + float transform_mat[3][3];
> + static const float identity_mat[3][3] = {{1.0, 0.0, 0.0},
> + {0.0, 1.0, 0.0},
> + {0.0, 0.0, 1.0}};
> + GLfloat stop_colors_st[RADIAL_SMALL_STOPS*4];
> + GLfloat n_stops_st[RADIAL_SMALL_STOPS];
> + GLfloat A_value;
> + GLfloat cxy[4];
> + float c1x, c1y, c2x, c2y, r1, r2;
> +
> + GLint transform_mat_uniform_location = 0;
> + GLint repeat_type_uniform_location = 0;
> + GLint n_stop_uniform_location = 0;
> + GLint stops_uniform_location = 0;
> + GLint stop_colors_uniform_location = 0;
> + GLint stop0_uniform_location = 0;
> + GLint stop1_uniform_location = 0;
> + GLint stop2_uniform_location = 0;
> + GLint stop3_uniform_location = 0;
> + GLint stop4_uniform_location = 0;
> + GLint stop5_uniform_location = 0;
> + GLint stop6_uniform_location = 0;
> + GLint stop7_uniform_location = 0;
> + GLint stop_color0_uniform_location = 0;
> + GLint stop_color1_uniform_location = 0;
> + GLint stop_color2_uniform_location = 0;
> + GLint stop_color3_uniform_location = 0;
> + GLint stop_color4_uniform_location = 0;
> + GLint stop_color5_uniform_location = 0;
> + GLint stop_color6_uniform_location = 0;
> + GLint stop_color7_uniform_location = 0;
> + GLint A_value_uniform_location = 0;
> + GLint c1_uniform_location = 0;
> + GLint r1_uniform_location = 0;
> + GLint c2_uniform_location = 0;
> + GLint r2_uniform_location = 0;
> +
> + glamor_priv = glamor_get_screen_private(screen);
> + dispatch = glamor_get_dispatch(glamor_priv);
> +
> + /* Create a pixmap with VBO. */
> + pixmap = glamor_create_pixmap(screen,
> + width, height,
> + PIXMAN_FORMAT_DEPTH(format),
> + 0);
> + if (!pixmap)
> + goto GRADIENT_FAIL;
> +
> + dst_picture = CreatePicture(0,&pixmap->drawable,
> + PictureMatchFormat(screen,
> + PIXMAN_FORMAT_DEPTH(format), format),
> + 0, 0, serverClient,&error);
> +
> + /* Release the reference, picture will hold the last one. */
> + glamor_destroy_pixmap(pixmap);
> +
> + if (!dst_picture)
> + goto GRADIENT_FAIL;
> +
> + ValidatePicture(dst_picture);
> +
> + stops_count = src_picture->pSourcePict->radial.nstops + 2;
> +
> + /* Because the max value of nstops is unkown, so create a program
> + when nstops> LINEAR_LARGE_STOPS.*/
> + if (stops_count<= RADIAL_SMALL_STOPS) {
> + gradient_prog = glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][0];
> + } else if (stops_count<= RADIAL_LARGE_STOPS) {
> + gradient_prog = glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][1];
> + } else {
> + _glamor_create_radial_gradient_program(screen,
> + src_picture->pSourcePict->linear.nstops + 2,
> + 1);
> + gradient_prog = glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][2];
> + }
> +
> + /* Bind all the uniform vars .*/
> + transform_mat_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "transform_mat");
> + repeat_type_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "repeat_type");
> + n_stop_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "n_stop");
> + A_value_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "A_value");
> + repeat_type_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "repeat_type");
> + c1_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "c1");
> + r1_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "r1");
> + c2_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "c2");
> + r2_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "r2");
> +
> + if (src_picture->pSourcePict->radial.nstops + 2<= RADIAL_SMALL_STOPS) {
> + stop0_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop0");
> + stop1_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop1");
> + stop2_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop2");
> + stop3_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop3");
> + stop4_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop4");
> + stop5_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop5");
> + stop6_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop6");
> + stop7_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop7");
> +
> + stop_color0_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color0");
> + stop_color1_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color1");
> + stop_color2_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color2");
> + stop_color3_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color3");
> + stop_color4_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color4");
> + stop_color5_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color5");
> + stop_color6_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color6");
> + stop_color7_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color7");
> + } else {
> + stops_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stops");
> + stop_colors_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_colors");
> + }
> +
> + dispatch->glUseProgram(gradient_prog);
> +
> + dispatch->glUniform1i(repeat_type_uniform_location, src_picture->repeatType);
> +
> +
> + if (src_picture->transform) {
> + _glamor_gradient_convert_trans_matrix(src_picture->transform,
> + transform_mat,
> + width, height, 0);
> + dispatch->glUniformMatrix3fv(transform_mat_uniform_location,
> + 1, 1,&transform_mat[0][0]);
> + } else {
> + dispatch->glUniformMatrix3fv(transform_mat_uniform_location,
> + 1, 1,&identity_mat[0][0]);
> + }
> +
> + if (!_glamor_gradient_set_pixmap_destination(screen, glamor_priv, dst_picture,
> + &xscale,&yscale, x_source, y_source,
> + vertices, tex_vertices, 0))
> + goto GRADIENT_FAIL;
> +
> + /* Set all the stops and colors to shader. */
> + if (stops_count> RADIAL_SMALL_STOPS) {
> + stop_colors = malloc(4 * stops_count * sizeof(float));
> + if (stop_colors == NULL) {
> + ErrorF("Failed to allocate stop_colors memory.\n");
> + goto GRADIENT_FAIL;
> + }
> +
> + n_stops = malloc(stops_count * sizeof(float));
> + if (n_stops == NULL) {
> + ErrorF("Failed to allocate n_stops memory.\n");
> + goto GRADIENT_FAIL;
> + }
> + } else {
> + stop_colors = stop_colors_st;
> + n_stops = n_stops_st;
> + }
> +
> + count = _glamor_gradient_set_stops(src_picture,&src_picture->pSourcePict->gradient,
> + stop_colors, n_stops);
> +
> + if (src_picture->pSourcePict->linear.nstops + 2<= RADIAL_SMALL_STOPS) {
> + int j = 0;
> + dispatch->glUniform4f(stop_color0_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> + j++;
> + dispatch->glUniform4f(stop_color1_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> + j++;
> + dispatch->glUniform4f(stop_color2_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> + j++;
> + dispatch->glUniform4f(stop_color3_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> + j++;
> + dispatch->glUniform4f(stop_color4_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> + j++;
> + dispatch->glUniform4f(stop_color5_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> + j++;
> + dispatch->glUniform4f(stop_color6_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> + j++;
> + dispatch->glUniform4f(stop_color7_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> +
> + j = 0;
> + dispatch->glUniform1f(stop0_uniform_location, n_stops[j++]);
> + dispatch->glUniform1f(stop1_uniform_location, n_stops[j++]);
> + dispatch->glUniform1f(stop2_uniform_location, n_stops[j++]);
> + dispatch->glUniform1f(stop3_uniform_location, n_stops[j++]);
> + dispatch->glUniform1f(stop4_uniform_location, n_stops[j++]);
> + dispatch->glUniform1f(stop5_uniform_location, n_stops[j++]);
> + dispatch->glUniform1f(stop6_uniform_location, n_stops[j++]);
> + dispatch->glUniform1f(stop7_uniform_location, n_stops[j++]);
> + dispatch->glUniform1i(n_stop_uniform_location, count);
> + } else {
> + dispatch->glUniform4fv(stop_colors_uniform_location, count, stop_colors);
> + dispatch->glUniform1fv(stops_uniform_location, count, n_stops);
> + dispatch->glUniform1i(n_stop_uniform_location, count);
> + }
> +
> + c1x = (float)pixman_fixed_to_double(src_picture->pSourcePict->radial.c1.x);
> + c1y = (float)pixman_fixed_to_double(src_picture->pSourcePict->radial.c1.y);
> + c2x = (float)pixman_fixed_to_double(src_picture->pSourcePict->radial.c2.x);
> + c2y = (float)pixman_fixed_to_double(src_picture->pSourcePict->radial.c2.y);
> +
> + r1 = (float)pixman_fixed_to_double(src_picture->pSourcePict->radial.c1.radius);
> + r2 = (float)pixman_fixed_to_double(src_picture->pSourcePict->radial.c2.radius);
> +
> +
> + cxy[0] = c1x;
> + cxy[1] = c1y;
> + dispatch->glUniform2fv(c1_uniform_location, 1, cxy);
> + dispatch->glUniform1f(r1_uniform_location, r1);
> +
> + cxy[0] = c2x;
> + cxy[1] = c2y;
> + dispatch->glUniform2fv(c2_uniform_location, 1, cxy);
> + dispatch->glUniform1f(r2_uniform_location, r2);
> +
> + A_value = (c2x - c1x) * (c2x - c1x) + (c2y - c1y) * (c2y - c1y) - (r2 - r1) * (r2 - r1);
> + dispatch->glUniform1f(A_value_uniform_location, A_value);
> +
> + DEBUGF("C1:(%f, %f) R1:%f\nC2:(%f, %f) R2:%f\nA = %f\n",
> + c1x, c1y, r1, c2x, c2y, r2, A_value);
> +
> + /* Now rendering. */
> + dispatch->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
> +
> + /* Do the clear logic.*/
> + if (stops_count> RADIAL_SMALL_STOPS) {
> + free(n_stops);
> + free(stop_colors);
> + }
> +
> + dispatch->glBindBuffer(GL_ARRAY_BUFFER, 0);
> + dispatch->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
> +
> + dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
> + dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
> + dispatch->glUseProgram(0);
> +
> + glamor_put_dispatch(glamor_priv);
> + return dst_picture;
> +
> +GRADIENT_FAIL:
> + if (dst_picture) {
> + FreePicture(dst_picture, 0);
> + }
> +
> + if (stops_count> RADIAL_SMALL_STOPS) {
> + if (n_stops)
> + free(n_stops);
> + if (stop_colors)
> + free(stop_colors);
> + }
> +
> + dispatch->glBindBuffer(GL_ARRAY_BUFFER, 0);
> + dispatch->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
> +
> + dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
> + dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
> + dispatch->glUseProgram(0);
> + glamor_put_dispatch(glamor_priv);
> + return NULL;
> +}
> +
> +PicturePtr
> +glamor_generate_linear_gradient_picture(ScreenPtr screen,
> + PicturePtr src_picture,
> + int x_source, int y_source,
> + int width, int height,
> + PictFormatShort format)
> +{
> + glamor_screen_private *glamor_priv;
> + glamor_gl_dispatch *dispatch;
> + PicturePtr dst_picture = NULL;
> + PixmapPtr pixmap = NULL;
> + GLint gradient_prog = 0;
> + int error;
> + float pt_distance;
> + float p1_distance;
> + GLfloat cos_val;
> + float tex_vertices[8];
> + int stops_count = 0;
> + GLfloat *stop_colors = NULL;
> + GLfloat *n_stops = NULL;
> + int count = 0;
> + float slope;
> + GLfloat xscale, yscale;
> + GLfloat pt1[4], pt2[4];
> + float vertices[8];
> + float transform_mat[3][3];
> + static const float identity_mat[3][3] = {{1.0, 0.0, 0.0},
> + {0.0, 1.0, 0.0},
> + {0.0, 0.0, 1.0}};
> + GLfloat stop_colors_st[LINEAR_SMALL_STOPS*4];
> + GLfloat n_stops_st[LINEAR_SMALL_STOPS];
> +
> + GLint transform_mat_uniform_location = 0;
> + GLint pt1_uniform_location = 0;
> + GLint pt2_uniform_location = 0;
> + GLint n_stop_uniform_location = 0;
> + GLint stops_uniform_location = 0;
> + GLint stop0_uniform_location = 0;
> + GLint stop1_uniform_location = 0;
> + GLint stop2_uniform_location = 0;
> + GLint stop3_uniform_location = 0;
> + GLint stop4_uniform_location = 0;
> + GLint stop5_uniform_location = 0;
> + GLint stop6_uniform_location = 0;
> + GLint stop7_uniform_location = 0;
> + GLint stop_colors_uniform_location = 0;
> + GLint stop_color0_uniform_location = 0;
> + GLint stop_color1_uniform_location = 0;
> + GLint stop_color2_uniform_location = 0;
> + GLint stop_color3_uniform_location = 0;
> + GLint stop_color4_uniform_location = 0;
> + GLint stop_color5_uniform_location = 0;
> + GLint stop_color6_uniform_location = 0;
> + GLint stop_color7_uniform_location = 0;
> + GLint pt_slope_uniform_location = 0;
> + GLint repeat_type_uniform_location = 0;
> + GLint hor_ver_uniform_location = 0;
> + GLint cos_val_uniform_location = 0;
> + GLint p1_distance_uniform_location = 0;
> + GLint pt_distance_uniform_location = 0;
> +
> + glamor_priv = glamor_get_screen_private(screen);
> + dispatch = glamor_get_dispatch(glamor_priv);
> +
> + /* Create a pixmap with VBO. */
> + pixmap = glamor_create_pixmap(screen,
> + width, height,
> + PIXMAN_FORMAT_DEPTH(format),
> + 0);
> +
> + if (!pixmap)
> + goto GRADIENT_FAIL;
> +
> + dst_picture = CreatePicture(0,&pixmap->drawable,
> + PictureMatchFormat(screen,
> + PIXMAN_FORMAT_DEPTH(format), format),
> + 0, 0, serverClient,&error);
> +
> + /* Release the reference, picture will hold the last one. */
> + glamor_destroy_pixmap(pixmap);
> +
> + if (!dst_picture)
> + goto GRADIENT_FAIL;
> +
> + ValidatePicture(dst_picture);
> +
> + stops_count = src_picture->pSourcePict->linear.nstops + 2;
> +
> + /* Because the max value of nstops is unkown, so create a program
> + when nstops> LINEAR_LARGE_STOPS.*/
> + if (stops_count<= LINEAR_SMALL_STOPS) {
> + gradient_prog = glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][0];
> + } else if (stops_count<= LINEAR_LARGE_STOPS) {
> + gradient_prog = glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][1];
> + } else {
> + _glamor_create_linear_gradient_program(screen,
> + src_picture->pSourcePict->linear.nstops + 2, 1);
> + gradient_prog = glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][2];
> + }
> +
> + /* Bind all the uniform vars .*/
> + pt1_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "pt1");
> + pt2_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "pt2");
> + n_stop_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "n_stop");
> + pt_slope_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "pt_slope");
> + repeat_type_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "repeat_type");
> + hor_ver_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "hor_ver");
> + transform_mat_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "transform_mat");
> + cos_val_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "cos_val");
> + p1_distance_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "p1_distance");
> + pt_distance_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "pt_distance");
> +
> + if (src_picture->pSourcePict->linear.nstops + 2<= LINEAR_SMALL_STOPS) {
> + stop0_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop0");
> + stop1_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop1");
> + stop2_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop2");
> + stop3_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop3");
> + stop4_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop4");
> + stop5_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop5");
> + stop6_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop6");
> + stop7_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop7");
> +
> + stop_color0_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color0");
> + stop_color1_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color1");
> + stop_color2_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color2");
> + stop_color3_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color3");
> + stop_color4_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color4");
> + stop_color5_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color5");
> + stop_color6_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color6");
> + stop_color7_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_color7");
> + } else {
> + stops_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stops");
> + stop_colors_uniform_location =
> + dispatch->glGetUniformLocation(gradient_prog, "stop_colors");
> + }
> +
> + dispatch->glUseProgram(gradient_prog);
> +
> + dispatch->glUniform1i(repeat_type_uniform_location, src_picture->repeatType);
> +
> + /* set the transform matrix. */
> + if (src_picture->transform) {
> + _glamor_gradient_convert_trans_matrix(src_picture->transform,
> + transform_mat,
> + width, height, 1);
> + dispatch->glUniformMatrix3fv(transform_mat_uniform_location,
> + 1, 1,&transform_mat[0][0]);
> + } else {
> + dispatch->glUniformMatrix3fv(transform_mat_uniform_location,
> + 1, 1,&identity_mat[0][0]);
> + }
> +
> + if (!_glamor_gradient_set_pixmap_destination(screen, glamor_priv, dst_picture,
> + &xscale,&yscale, x_source, y_source,
> + vertices, tex_vertices, 1))
> + goto GRADIENT_FAIL;
> +
> + /* Normalize the PTs. */
> + glamor_set_normalize_pt(xscale, yscale,
> + pixman_fixed_to_int(src_picture->pSourcePict->linear.p1.x),
> + x_source,
> + pixman_fixed_to_int(src_picture->pSourcePict->linear.p1.y),
> + y_source,
> + glamor_priv->yInverted,
> + pt1);
> + dispatch->glUniform4fv(pt1_uniform_location, 1, pt1);
> + DEBUGF("pt1:(%f %f)\n", pt1[0], pt1[1]);
> +
> + glamor_set_normalize_pt(xscale, yscale,
> + pixman_fixed_to_int(src_picture->pSourcePict->linear.p2.x),
> + x_source,
> + pixman_fixed_to_int(src_picture->pSourcePict->linear.p2.y),
> + y_source,
> + glamor_priv->yInverted,
> + pt2);
> + dispatch->glUniform4fv(pt2_uniform_location, 1, pt2);
> + DEBUGF("pt2:(%f %f)\n", pt2[0], pt2[1]);
> +
> + /* Set all the stops and colors to shader. */
> + if (stops_count> LINEAR_SMALL_STOPS) {
> + stop_colors = malloc(4 * stops_count * sizeof(float));
> + if (stop_colors == NULL) {
> + ErrorF("Failed to allocate stop_colors memory.\n");
> + goto GRADIENT_FAIL;
> + }
> +
> + n_stops = malloc(stops_count * sizeof(float));
> + if (n_stops == NULL) {
> + ErrorF("Failed to allocate n_stops memory.\n");
> + goto GRADIENT_FAIL;
> + }
> + } else {
> + stop_colors = stop_colors_st;
> + n_stops = n_stops_st;
> + }
> +
> + count = _glamor_gradient_set_stops(src_picture,&src_picture->pSourcePict->gradient,
> + stop_colors, n_stops);
> +
> + if (src_picture->pSourcePict->linear.nstops + 2<= LINEAR_SMALL_STOPS) {
> + int j = 0;
> + dispatch->glUniform4f(stop_color0_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> + j++;
> + dispatch->glUniform4f(stop_color1_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> + j++;
> + dispatch->glUniform4f(stop_color2_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> + j++;
> + dispatch->glUniform4f(stop_color3_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> + j++;
> + dispatch->glUniform4f(stop_color4_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> + j++;
> + dispatch->glUniform4f(stop_color5_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> + j++;
> + dispatch->glUniform4f(stop_color6_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> + j++;
> + dispatch->glUniform4f(stop_color7_uniform_location,
> + stop_colors[4*j+0], stop_colors[4*j+1],
> + stop_colors[4*j+2], stop_colors[4*j+3]);
> +
> + j = 0;
> + dispatch->glUniform1f(stop0_uniform_location, n_stops[j++]);
> + dispatch->glUniform1f(stop1_uniform_location, n_stops[j++]);
> + dispatch->glUniform1f(stop2_uniform_location, n_stops[j++]);
> + dispatch->glUniform1f(stop3_uniform_location, n_stops[j++]);
> + dispatch->glUniform1f(stop4_uniform_location, n_stops[j++]);
> + dispatch->glUniform1f(stop5_uniform_location, n_stops[j++]);
> + dispatch->glUniform1f(stop6_uniform_location, n_stops[j++]);
> + dispatch->glUniform1f(stop7_uniform_location, n_stops[j++]);
> +
> + dispatch->glUniform1i(n_stop_uniform_location, count);
> + } else {
> + dispatch->glUniform4fv(stop_colors_uniform_location, count, stop_colors);
> + dispatch->glUniform1fv(stops_uniform_location, count, n_stops);
> + dispatch->glUniform1i(n_stop_uniform_location, count);
> + }
> +
> + if (abs((pt2[1] - pt1[1]) / yscale)< 1.0) { // The horizontal case.
> + dispatch->glUniform1i(hor_ver_uniform_location, 1);
> + DEBUGF("p1.x: %f, p2.x: %f, enter the horizontal case\n", pt1[1], pt2[1]);
> +
> + p1_distance = pt1[0];
> + pt_distance = (pt2[0] - p1_distance);
> + dispatch->glUniform1f(p1_distance_uniform_location, p1_distance);
> + dispatch->glUniform1f(pt_distance_uniform_location, pt_distance);
> + } else if (abs((pt2[0] - pt1[0]) / xscale)< 1.0) { //The vertical case.
> + dispatch->glUniform1i(hor_ver_uniform_location, 2);
> + DEBUGF("p1.y: %f, p2.y: %f, enter the vertical case\n", pt1[0], pt2[0]);
> +
> + p1_distance = pt1[1];
> + pt_distance = (pt2[1] - p1_distance);
> + dispatch->glUniform1f(p1_distance_uniform_location, p1_distance);
> + dispatch->glUniform1f(pt_distance_uniform_location, pt_distance);
> + } else {
> + /* The slope need to compute here. In shader, the viewport set will change
> + the orginal slope and the slope which is vertical to it will not be correct.*/
> + slope = - (float)(src_picture->pSourcePict->linear.p2.x
> + - src_picture->pSourcePict->linear.p1.x) /
> + (float)(src_picture->pSourcePict->linear.p2.y
> + - src_picture->pSourcePict->linear.p1.y);
> + slope = slope * yscale / xscale;
> + dispatch->glUniform1f(pt_slope_uniform_location, slope);
> + dispatch->glUniform1i(hor_ver_uniform_location, 0);
> +
> + cos_val = sqrt(1.0 / (slope * slope + 1.0));
> + dispatch->glUniform1f(cos_val_uniform_location, cos_val);
> +
> + p1_distance = (pt1[1] - pt1[0] * slope) * cos_val;
> + pt_distance = (pt2[1] - pt2[0] * slope) * cos_val - p1_distance;
> + dispatch->glUniform1f(p1_distance_uniform_location, p1_distance);
> + dispatch->glUniform1f(pt_distance_uniform_location, pt_distance);
> + }
> +
> + /* Now rendering. */
> + dispatch->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
> +
> + /* Do the clear logic.*/
> + if (stops_count> LINEAR_SMALL_STOPS) {
> + free(n_stops);
> + free(stop_colors);
> + }
> +
> + dispatch->glBindBuffer(GL_ARRAY_BUFFER, 0);
> + dispatch->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
> +
> + dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
> + dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
> + dispatch->glUseProgram(0);
> +
> + glamor_put_dispatch(glamor_priv);
> + return dst_picture;
> +
> +GRADIENT_FAIL:
> + if (dst_picture) {
> + FreePicture(dst_picture, 0);
> + }
> +
> + if (stops_count> LINEAR_SMALL_STOPS) {
> + if (n_stops)
> + free(n_stops);
> + if (stop_colors)
> + free(stop_colors);
> + }
> +
> + dispatch->glBindBuffer(GL_ARRAY_BUFFER, 0);
> + dispatch->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
> +
> + dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
> + dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
> + dispatch->glUseProgram(0);
> + glamor_put_dispatch(glamor_priv);
> + return NULL;
> +}
> +
> +#endif /* End of GLAMOR_GRADIENT_SHADER */
> +
> +#endif /* End of RENDER */
> diff --git a/src/glamor_priv.h b/src/glamor_priv.h
> index d26f59f..e0a7d2c 100644
> --- a/src/glamor_priv.h
> +++ b/src/glamor_priv.h
> @@ -577,8 +577,19 @@ Bool glamor_tile(PixmapPtr pixmap, PixmapPtr tile,
> void glamor_init_tile_shader(ScreenPtr screen);
> void glamor_fini_tile_shader(ScreenPtr screen);
>
> +/* glamor_gradient.c */
> void glamor_init_gradient_shader(ScreenPtr screen);
> void glamor_fini_gradient_shader(ScreenPtr screen);
> +PicturePtr glamor_generate_linear_gradient_picture(ScreenPtr screen,
> + PicturePtr src_picture,
> + int x_source, int y_source,
> + int width, int height,
> + PictFormatShort format);
> +PicturePtr glamor_generate_radial_gradient_picture(ScreenPtr screen,
> + PicturePtr src_picture,
> + int x_source, int y_source,
> + int width, int height,
> + PictFormatShort format);
>
> /* glamor_triangles.c */
> void
> @@ -744,7 +755,7 @@ glamor_poly_line(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
>
> #define GLAMOR_PIXMAP_DYNAMIC_UPLOAD
> #ifndef GLAMOR_GLES2
> -//#define GLAMOR_GRADIENT_SHADER
> +#define GLAMOR_GRADIENT_SHADER
> #endif
>
> #endif /* GLAMOR_PRIV_H */
> diff --git a/src/glamor_render.c b/src/glamor_render.c
> index a17b6fd..5184b93 100644
> --- a/src/glamor_render.c
> +++ b/src/glamor_render.c
> @@ -745,7 +745,6 @@ glamor_setup_composite_vbo(ScreenPtr screen, int n_verts)
> glamor_gl_dispatch *dispatch;
>
> glamor_priv->vbo_offset = 0;
> - glamor_priv->vbo_offset = 0;
> glamor_priv->render_nr_verts = 0;
> glamor_priv->vbo_size = n_verts * sizeof(float) * 2;
>
> @@ -1339,1583 +1338,6 @@ done:
> return ret;
> }
>
> -#ifdef GLAMOR_GRADIENT_SHADER
> -static GLint
> -_glamor_create_getcolor_fs_program(ScreenPtr screen, int stops_count, int use_array)
> -{
> - glamor_screen_private *glamor_priv;
> - glamor_gl_dispatch *dispatch;
> -
> - char *gradient_fs = NULL;
> - GLint fs_getcolor_prog;
> -
> - const char *gradient_fs_getcolor =
> - GLAMOR_DEFAULT_PRECISION
> - "uniform int n_stop;\n"
> - "uniform float stops[%d];\n"
> - "uniform vec4 stop_colors[%d];\n"
> - "vec4 get_color(float stop_len)\n"
> - "{\n"
> - " int i = 0;\n"
> - " float new_alpha; \n"
> - " vec4 gradient_color;\n"
> - " float percentage; \n"
> - " for(i = 0; i< n_stop - 1; i++) {\n"
> - " if(stop_len< stops[i])\n"
> - " break; \n"
> - " }\n"
> - " \n"
> - " percentage = (stop_len - stops[i-1])/(stops[i] - stops[i-1]);\n"
> - " if(stops[i] - stops[i-1]> 2.0)\n"
> - " percentage = 0.0;\n" //For comply with pixman, walker->stepper overflow.
> - " new_alpha = percentage * stop_colors[i].a + \n"
> - " (1.0-percentage) * stop_colors[i-1].a; \n"
> - " gradient_color = vec4((percentage * stop_colors[i].rgb \n"
> - " + (1.0-percentage) * stop_colors[i-1].rgb)*new_alpha, \n"
> - " new_alpha);\n"
> - " \n"
> - " return gradient_color;\n"
> - "}\n";
> -
> - /* Because the array access for shader is very slow, the performance is very low
> - if use array. So use global uniform to replace for it if the number of n_stops is small.*/
> - const char *gradient_fs_getcolor_no_array =
> - GLAMOR_DEFAULT_PRECISION
> - "uniform int n_stop;\n"
> - "uniform float stop0;\n"
> - "uniform float stop1;\n"
> - "uniform float stop2;\n"
> - "uniform float stop3;\n"
> - "uniform float stop4;\n"
> - "uniform float stop5;\n"
> - "uniform float stop6;\n"
> - "uniform float stop7;\n"
> - "uniform vec4 stop_color0;\n"
> - "uniform vec4 stop_color1;\n"
> - "uniform vec4 stop_color2;\n"
> - "uniform vec4 stop_color3;\n"
> - "uniform vec4 stop_color4;\n"
> - "uniform vec4 stop_color5;\n"
> - "uniform vec4 stop_color6;\n"
> - "uniform vec4 stop_color7;\n"
> - "\n"
> - "vec4 get_color(float stop_len)\n"
> - "{\n"
> - " float stop_after;\n"
> - " float stop_before;\n"
> - " vec4 stop_color_before;\n"
> - " vec4 stop_color_after;\n"
> - " float new_alpha; \n"
> - " vec4 gradient_color;\n"
> - " float percentage; \n"
> - " \n"
> - " if((stop_len< stop0)&& (n_stop>= 1)) {\n"
> - " stop_color_before = stop_color0;\n"
> - " stop_color_after = stop_color0;\n"
> - " stop_after = stop0;\n"
> - " stop_before = stop0;\n"
> - " percentage = 0.0;\n"
> - " } else if((stop_len< stop1)&& (n_stop>= 2)) {\n"
> - " stop_color_before = stop_color0;\n"
> - " stop_color_after = stop_color1;\n"
> - " stop_after = stop1;\n"
> - " stop_before = stop0;\n"
> - " percentage = (stop_len - stop0)/(stop1 - stop0);\n"
> - " } else if((stop_len< stop2)&& (n_stop>= 3)) {\n"
> - " stop_color_before = stop_color1;\n"
> - " stop_color_after = stop_color2;\n"
> - " stop_after = stop2;\n"
> - " stop_before = stop1;\n"
> - " percentage = (stop_len - stop1)/(stop2 - stop1);\n"
> - " } else if((stop_len< stop3)&& (n_stop>= 4)){\n"
> - " stop_color_before = stop_color2;\n"
> - " stop_color_after = stop_color3;\n"
> - " stop_after = stop3;\n"
> - " stop_before = stop2;\n"
> - " percentage = (stop_len - stop2)/(stop3 - stop2);\n"
> - " } else if((stop_len< stop4)&& (n_stop>= 5)){\n"
> - " stop_color_before = stop_color3;\n"
> - " stop_color_after = stop_color4;\n"
> - " stop_after = stop4;\n"
> - " stop_before = stop3;\n"
> - " percentage = (stop_len - stop3)/(stop4 - stop3);\n"
> - " } else if((stop_len< stop5)&& (n_stop>= 6)){\n"
> - " stop_color_before = stop_color4;\n"
> - " stop_color_after = stop_color5;\n"
> - " stop_after = stop5;\n"
> - " stop_before = stop4;\n"
> - " percentage = (stop_len - stop4)/(stop5 - stop4);\n"
> - " } else if((stop_len< stop6)&& (n_stop>= 7)){\n"
> - " stop_color_before = stop_color5;\n"
> - " stop_color_after = stop_color6;\n"
> - " stop_after = stop6;\n"
> - " stop_before = stop5;\n"
> - " percentage = (stop_len - stop5)/(stop6 - stop5);\n"
> - " } else if((stop_len< stop7)&& (n_stop>= 8)){\n"
> - " stop_color_before = stop_color6;\n"
> - " stop_color_after = stop_color7;\n"
> - " stop_after = stop7;\n"
> - " stop_before = stop6;\n"
> - " percentage = (stop_len - stop6)/(stop7 - stop6);\n"
> - " } else {\n"
> - " stop_color_before = stop_color7;\n"
> - " stop_color_after = stop_color7;\n"
> - " stop_after = stop7;\n"
> - " stop_before = stop7;\n"
> - " percentage = 0.0;\n"
> - " }\n"
> - " if(stop_after - stop_before> 2.0)\n"
> - " percentage = 0.0;\n"//For comply with pixman, walker->stepper overflow.
> - " new_alpha = percentage * stop_color_after.a + \n"
> - " (1.0-percentage) * stop_color_before.a; \n"
> - " gradient_color = vec4((percentage * stop_color_after.rgb \n"
> - " + (1.0-percentage) * stop_color_before.rgb)*new_alpha, \n"
> - " new_alpha);\n"
> - " \n"
> - " return gradient_color;\n"
> - "}\n";
> -
> - glamor_priv = glamor_get_screen_private(screen);
> - dispatch = glamor_get_dispatch(glamor_priv);
> -
> - if(use_array) {
> - XNFasprintf(&gradient_fs,
> - gradient_fs_getcolor, stops_count, stops_count);
> - fs_getcolor_prog = glamor_compile_glsl_prog(dispatch, GL_FRAGMENT_SHADER,
> - gradient_fs);
> - free(gradient_fs);
> - } else {
> - fs_getcolor_prog = glamor_compile_glsl_prog(dispatch, GL_FRAGMENT_SHADER,
> - gradient_fs_getcolor_no_array);
> - }
> -
> - return fs_getcolor_prog;
> -}
> -
> -static void
> -_glamor_create_radial_gradient_program(ScreenPtr screen, int stops_count, int dyn_gen)
> -{
> - glamor_screen_private *glamor_priv;
> - glamor_gl_dispatch *dispatch;
> - int index;
> -
> - GLint gradient_prog = 0;
> - char *gradient_fs = NULL;
> - GLint fs_main_prog, fs_getcolor_prog, vs_prog;
> -
> - const char *gradient_vs =
> - GLAMOR_DEFAULT_PRECISION
> - "attribute vec4 v_position;\n"
> - "attribute vec4 v_texcoord;\n"
> - "varying vec2 source_texture;\n"
> - "\n"
> - "void main()\n"
> - "{\n"
> - " gl_Position = v_position;\n"
> - " source_texture = v_texcoord.xy;\n"
> - "}\n";
> -
> - /*
> - * Refer to pixman radial gradient.
> - *
> - * The problem is given the two circles of c1 and c2 with the radius of r1 and
> - * r1, we need to caculate the t, which is used to do interpolate with stops,
> - * using the fomula:
> - * length((1-t)*c1 + t*c2 - p) = (1-t)*r1 + t*r2
> - * expand the fomula with xy coond, get the following:
> - * sqrt(sqr((1-t)*c1.x + t*c2.x - p.x) + sqr((1-t)*c1.y + t*c2.y - p.y))
> - * = (1-t)r1 + t*r2
> - *<====> At*t- 2Bt + C = 0
> - * where A = sqr(c2.x - c1.x) + sqr(c2.y - c1.y) - sqr(r2 -r1)
> - * B = (p.x - c1.x)*(c2.x - c1.x) + (p.y - c1.y)*(c2.y - c1.y) + r1*(r2 -r1)
> - * C = sqr(p.x - c1.x) + sqr(p.y - c1.y) - r1*r1
> - *
> - * solve the fomula and we get the result of
> - * t = (B + sqrt(B*B - A*C)) / A or
> - * t = (B - sqrt(B*B - A*C)) / A (quadratic equation have two solutions)
> - *
> - * The solution we are going to prefer is the bigger one, unless the
> - * radius associated to it is negative (or it falls outside the valid t range)
> - */
> -
> - const char *gradient_fs_template =
> - GLAMOR_DEFAULT_PRECISION
> - "uniform mat3 transform_mat;\n"
> - "uniform int repeat_type;\n"
> - "uniform float A_value;\n"
> - "uniform vec2 c1;\n"
> - "uniform float r1;\n"
> - "uniform vec2 c2;\n"
> - "uniform float r2;\n"
> - "varying vec2 source_texture;\n"
> - "\n"
> - "vec4 get_color(float stop_len);\n"
> - "\n"
> - "int t_invalid;\n"
> - "\n"
> - "float get_stop_len()\n"
> - "{\n"
> - " float t = 0.0;\n"
> - " float sqrt_value;\n"
> - " int revserse = 0;\n"
> - " t_invalid = 0;\n"
> - " \n"
> - " vec3 tmp = vec3(source_texture.x, source_texture.y, 1.0);\n"
> - " vec3 source_texture_trans = transform_mat * tmp;\n"
> - " source_texture_trans.xy = source_texture_trans.xy/source_texture_trans.z;\n"
> - " float B_value = (source_texture_trans.x - c1.x) * (c2.x - c1.x)\n"
> - " + (source_texture_trans.y - c1.y) * (c2.y - c1.y)\n"
> - " + r1 * (r2 - r1);\n"
> - " float C_value = (source_texture_trans.x - c1.x) * (source_texture_trans.x - c1.x)\n"
> - " + (source_texture_trans.y - c1.y) * (source_texture_trans.y - c1.y)\n"
> - " - r1*r1;\n"
> - " if(abs(A_value)< 0.00001) {\n"
> - " if(B_value == 0.0) {\n"
> - " t_invalid = 1;\n"
> - " return t;\n"
> - " }\n"
> - " t = 0.5 * C_value / B_value;"
> - " } else {\n"
> - " sqrt_value = B_value * B_value - A_value * C_value;\n"
> - " if(sqrt_value< 0.0) {\n"
> - " t_invalid = 1;\n"
> - " return t;\n"
> - " }\n"
> - " sqrt_value = sqrt(sqrt_value);\n"
> - " t = (B_value + sqrt_value) / A_value;\n"
> - " }\n"
> - " if(repeat_type == %d) {\n" // RepeatNone case.
> - " if((t<= 0.0) || (t> 1.0))\n"
> - // try another if first one invalid
> - " t = (B_value - sqrt_value) / A_value;\n"
> - " \n"
> - " if((t<= 0.0) || (t> 1.0)) {\n" //still invalid, return.
> - " t_invalid = 1;\n"
> - " return t;\n"
> - " }\n"
> - " } else {\n"
> - " if(t * (r2 - r1)<= -1.0 * r1)\n"
> - // try another if first one invalid
> - " t = (B_value - sqrt_value) / A_value;\n"
> - " \n"
> - " if(t * (r2 -r1)<= -1.0 * r1) {\n" //still invalid, return.
> - " t_invalid = 1;\n"
> - " return t;\n"
> - " }\n"
> - " }\n"
> - " \n"
> - " if(repeat_type == %d){\n" // repeat normal
> - " while(t> 1.0) \n"
> - " t = t - 1.0; \n"
> - " while(t< 0.0) \n"
> - " t = t + 1.0; \n"
> - " }\n"
> - " \n"
> - " if(repeat_type == %d) {\n" // repeat reflect
> - " while(t> 1.0) {\n"
> - " t = t - 1.0; \n"
> - " if(revserse == 0)\n"
> - " revserse = 1;\n"
> - " else\n"
> - " revserse = 0;\n"
> - " }\n"
> - " while(t< 0.0) {\n"
> - " t = t + 1.0; \n"
> - " if(revserse == 0)\n"
> - " revserse = 1;\n"
> - " else\n"
> - " revserse = 0;\n"
> - " }\n"
> - " if(revserse == 1) {\n"
> - " t = 1.0 - t; \n"
> - " }\n"
> - " }\n"
> - " \n"
> - " return t;\n"
> - "}\n"
> - "\n"
> - "void main()\n"
> - "{\n"
> - " float stop_len = get_stop_len();\n"
> - " if(t_invalid == 1) {\n"
> - " gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);\n"
> - " } else {\n"
> - " gl_FragColor = get_color(stop_len);\n"
> - " }\n"
> - "}\n";
> -
> - glamor_priv = glamor_get_screen_private(screen);
> -
> - if ((glamor_priv->radial_max_nstops>= stops_count)&& (dyn_gen)) {
> - /* Very Good, not to generate again. */
> - return;
> - }
> -
> - dispatch = glamor_get_dispatch(glamor_priv);
> -
> - if (dyn_gen&& glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][2]) {
> - dispatch->glDeleteShader(
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_VS_PROG][2]);
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_VS_PROG][2] = 0;
> -
> - dispatch->glDeleteShader(
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][2]);
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][2] = 0;
> -
> - dispatch->glDeleteShader(
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][2]);
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][2] = 0;
> -
> - dispatch->glDeleteProgram(glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][2]);
> - glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][2] = 0;
> - }
> -
> - gradient_prog = dispatch->glCreateProgram();
> -
> - vs_prog = glamor_compile_glsl_prog(dispatch,
> - GL_VERTEX_SHADER, gradient_vs);
> -
> - XNFasprintf(&gradient_fs,
> - gradient_fs_template,
> - PIXMAN_REPEAT_NONE, PIXMAN_REPEAT_NORMAL, PIXMAN_REPEAT_REFLECT);
> -
> - fs_main_prog = glamor_compile_glsl_prog(dispatch,
> - GL_FRAGMENT_SHADER, gradient_fs);
> -
> - free(gradient_fs);
> -
> - fs_getcolor_prog =
> - _glamor_create_getcolor_fs_program(screen, stops_count, (stops_count> 0));
> -
> - dispatch->glAttachShader(gradient_prog, vs_prog);
> - dispatch->glAttachShader(gradient_prog, fs_getcolor_prog);
> - dispatch->glAttachShader(gradient_prog, fs_main_prog);
> -
> - dispatch->glBindAttribLocation(gradient_prog, GLAMOR_VERTEX_POS, "v_positionsition");
> - dispatch->glBindAttribLocation(gradient_prog, GLAMOR_VERTEX_SOURCE, "v_texcoord");
> -
> - glamor_link_glsl_prog(dispatch, gradient_prog);
> -
> - dispatch->glUseProgram(0);
> -
> - if (dyn_gen) {
> - index = 2;
> - glamor_priv->radial_max_nstops = stops_count;
> - } else if (stops_count) {
> - index = 1;
> - } else {
> - index = 0;
> - }
> -
> - glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][index] = gradient_prog;
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_VS_PROG][index] = vs_prog;
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][index] = fs_main_prog;
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][index] = fs_getcolor_prog;
> -
> - glamor_put_dispatch(glamor_priv);
> -}
> -
> -static void
> -_glamor_create_linear_gradient_program(ScreenPtr screen, int stops_count, int dyn_gen)
> -{
> - glamor_screen_private *glamor_priv;
> - glamor_gl_dispatch *dispatch;
> -
> - int index = 0;
> - GLint gradient_prog = 0;
> - char *gradient_fs = NULL;
> - GLint fs_main_prog, fs_getcolor_prog, vs_prog;
> -
> - const char *gradient_vs =
> - GLAMOR_DEFAULT_PRECISION
> - "attribute vec4 v_position;\n"
> - "attribute vec4 v_texcoord;\n"
> - "varying vec2 source_texture;\n"
> - "\n"
> - "void main()\n"
> - "{\n"
> - " gl_Position = v_position;\n"
> - " source_texture = v_texcoord.xy;\n"
> - "}\n";
> -
> - /*
> - * |
> - * |\
> - * | \
> - * | \
> - * | \
> - * |\ \
> - * | \ \
> - * cos_val = |\ p1d \ /
> - * sqrt(1/(slope*slope+1.0)) ------>\ \ \ /
> - * | \ \ \
> - * | \ \ / \
> - * | \ *Pt1\
> - * *p1 | \ \ *P
> - * \ | / \ \ /
> - * \ | / \ \ /
> - * \ | pd \
> - * \ | \ / \
> - * p2* | \ / \ /
> - * slope = (p2.y - p1.y) / | / p2d /
> - * (p2.x - p1.x) | / \ /
> - * | / \ /
> - * | / /
> - * | / /
> - * | / *Pt2
> - * | /
> - * | /
> - * | /
> - * | /
> - * | /
> - * -------+---------------------------------
> - * O|
> - * |
> - * |
> - *
> - * step 1: compute the distance of p, pt1 and pt2 in the slope direction.
> - * Caculate the distance on Y axis first and multiply cos_val to
> - * get the value on slope direction(pd, p1d and p2d represent the
> - * distance of p, pt1, and pt2 respectively).
> - *
> - * step 2: caculate the percentage of (pd - p1d)/(p2d - p1d).
> - * If (pd - p1d)> (p2d - p1d) or< 0, then sub or add (p2d - p1d)
> - * to make it in the range of [0, (p2d - p1d)].
> - *
> - * step 3: compare the percentage to every stop and find the stpos just
> - * before and after it. Use the interpolation fomula to compute RGBA.
> - */
> -
> - const char *gradient_fs_template =
> - GLAMOR_DEFAULT_PRECISION
> - "uniform mat3 transform_mat;\n"
> - "uniform int repeat_type;\n"
> - "uniform int hor_ver;\n"
> - "uniform vec4 pt1;\n"
> - "uniform vec4 pt2;\n"
> - "uniform float pt_slope;\n"
> - "uniform float cos_val;\n"
> - "uniform float p1_distance;\n"
> - "uniform float pt_distance;\n"
> - "varying vec2 source_texture;\n"
> - "\n"
> - "vec4 get_color(float stop_len);\n"
> - "\n"
> - "float get_stop_len()\n"
> - "{\n"
> - " vec3 tmp = vec3(source_texture.x, source_texture.y, 1.0);\n"
> - " float len_percentage;\n"
> - " float distance;\n"
> - " float _p1_distance;\n"
> - " float _pt_distance;\n"
> - " float y_dist;\n"
> - " float stop_after;\n"
> - " float stop_before;\n"
> - " vec4 stop_color_before;\n"
> - " vec4 stop_color_after;\n"
> - " float new_alpha; \n"
> - " int revserse = 0;\n"
> - " vec4 gradient_color;\n"
> - " float percentage; \n"
> - " vec3 source_texture_trans = transform_mat * tmp;\n"
> - " \n"
> - " if(hor_ver == 0) { \n" //Normal case.
> - " y_dist = source_texture_trans.y - source_texture_trans.x*pt_slope;\n"
> - " distance = y_dist * cos_val;\n"
> - " _p1_distance = p1_distance * source_texture_trans.z;\n"
> - " _pt_distance = pt_distance * source_texture_trans.z;\n"
> - " \n"
> - " } else if (hor_ver == 1) {\n"//horizontal case.
> - " distance = source_texture_trans.x;\n"
> - " _p1_distance = p1_distance * source_texture_trans.z;\n"
> - " _pt_distance = pt_distance * source_texture_trans.z;\n"
> - " } else if (hor_ver == 2) {\n"//vertical case.
> - " distance = source_texture_trans.y;\n"
> - " _p1_distance = p1_distance * source_texture_trans.z;\n"
> - " _pt_distance = pt_distance * source_texture_trans.z;\n"
> - " } \n"
> - " \n"
> - " distance = distance - _p1_distance; \n"
> - " \n"
> - " if(repeat_type == %d){\n" // repeat normal
> - " while(distance> _pt_distance) \n"
> - " distance = distance - (_pt_distance); \n"
> - " while(distance< 0.0) \n"
> - " distance = distance + (_pt_distance); \n"
> - " }\n"
> - " \n"
> - " if(repeat_type == %d) {\n" // repeat reflect
> - " while(distance> _pt_distance) {\n"
> - " distance = distance - (_pt_distance); \n"
> - " if(revserse == 0)\n"
> - " revserse = 1;\n"
> - " else\n"
> - " revserse = 0;\n"
> - " }\n"
> - " while(distance< 0.0) {\n"
> - " distance = distance + (_pt_distance); \n"
> - " if(revserse == 0)\n"
> - " revserse = 1;\n"
> - " else\n"
> - " revserse = 0;\n"
> - " }\n"
> - " if(revserse == 1) {\n"
> - " distance = (_pt_distance) - distance; \n"
> - " }\n"
> - " }\n"
> - " \n"
> - " len_percentage = distance/(_pt_distance);\n"
> - " \n"
> - " return len_percentage;\n"
> - "}\n"
> - "\n"
> - "void main()\n"
> - "{\n"
> - " float stop_len = get_stop_len();\n"
> - " gl_FragColor = get_color(stop_len);\n"
> - "}\n";
> -
> -
> - glamor_priv = glamor_get_screen_private(screen);
> -
> - if ((glamor_priv->linear_max_nstops>= stops_count)&& (dyn_gen)) {
> - /* Very Good, not to generate again. */
> - return;
> - }
> -
> - dispatch = glamor_get_dispatch(glamor_priv);
> - if (dyn_gen&& glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][2]) {
> - dispatch->glDeleteShader(
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_VS_PROG][2]);
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_VS_PROG][2] = 0;
> -
> - dispatch->glDeleteShader(
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][2]);
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][2] = 0;
> -
> - dispatch->glDeleteShader(
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][2]);
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][2] = 0;
> -
> - dispatch->glDeleteProgram(glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][2]);
> - glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][2] = 0;
> - }
> -
> - gradient_prog = dispatch->glCreateProgram();
> -
> - vs_prog = glamor_compile_glsl_prog(dispatch,
> - GL_VERTEX_SHADER, gradient_vs);
> -
> - XNFasprintf(&gradient_fs,
> - gradient_fs_template,
> - PIXMAN_REPEAT_NORMAL, PIXMAN_REPEAT_REFLECT);
> -
> - fs_main_prog = glamor_compile_glsl_prog(dispatch,
> - GL_FRAGMENT_SHADER, gradient_fs);
> - free(gradient_fs);
> -
> - fs_getcolor_prog =
> - _glamor_create_getcolor_fs_program(screen, stops_count, (stops_count> 0));
> -
> - dispatch->glAttachShader(gradient_prog, vs_prog);
> - dispatch->glAttachShader(gradient_prog, fs_getcolor_prog);
> - dispatch->glAttachShader(gradient_prog, fs_main_prog);
> -
> - dispatch->glBindAttribLocation(gradient_prog, GLAMOR_VERTEX_POS, "v_position");
> - dispatch->glBindAttribLocation(gradient_prog, GLAMOR_VERTEX_SOURCE, "v_texcoord");
> -
> - glamor_link_glsl_prog(dispatch, gradient_prog);
> -
> - dispatch->glUseProgram(0);
> -
> - if (dyn_gen) {
> - index = 2;
> - glamor_priv->linear_max_nstops = stops_count;
> - } else if (stops_count) {
> - index = 1;
> - } else {
> - index = 0;
> - }
> -
> - glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][index] = gradient_prog;
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_VS_PROG][index] = vs_prog;
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][index] = fs_main_prog;
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][index] = fs_getcolor_prog;
> -
> - glamor_put_dispatch(glamor_priv);
> -}
> -
> -#define LINEAR_SMALL_STOPS 6 + 2
> -#define LINEAR_LARGE_STOPS 16 + 2
> -
> -#define RADIAL_SMALL_STOPS 6 + 2
> -#define RADIAL_LARGE_STOPS 16 + 2
> -
> -void
> -glamor_init_gradient_shader(ScreenPtr screen)
> -{
> - glamor_screen_private *glamor_priv;
> - int i;
> -
> - glamor_priv = glamor_get_screen_private(screen);
> -
> - for (i = 0; i< 3; i++) {
> - glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][i] = 0;
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_VS_PROG][i] = 0;
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][i] = 0;
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][i] = 0;
> -
> - glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][i] = 0;
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_VS_PROG][i] = 0;
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][i] = 0;
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][i] = 0;
> - }
> - glamor_priv->linear_max_nstops = 0;
> - glamor_priv->radial_max_nstops = 0;
> -
> - _glamor_create_linear_gradient_program(screen, 0, 0);
> - _glamor_create_linear_gradient_program(screen, LINEAR_LARGE_STOPS, 0);
> -
> - _glamor_create_radial_gradient_program(screen, 0, 0);
> - _glamor_create_radial_gradient_program(screen, RADIAL_LARGE_STOPS, 0);
> -}
> -
> -void
> -glamor_fini_gradient_shader(ScreenPtr screen)
> -{
> - glamor_screen_private *glamor_priv;
> - glamor_gl_dispatch *dispatch;
> - int i = 0;
> -
> - glamor_priv = glamor_get_screen_private(screen);
> - dispatch = glamor_get_dispatch(glamor_priv);
> -
> - for (i = 0; i< 3; i++) {
> - /* Linear Gradient */
> - if (glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_VS_PROG][i])
> - dispatch->glDeleteShader(
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_VS_PROG][i]);
> -
> - if (glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][i])
> - dispatch->glDeleteShader(
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][i]);
> -
> - if (glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][i])
> - dispatch->glDeleteShader(
> - glamor_priv->linear_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][i]);
> -
> - if (glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][i])
> - dispatch->glDeleteProgram(glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][i]);
> -
> - /* Radial Gradient */
> - if (glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_VS_PROG][i])
> - dispatch->glDeleteShader(
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_VS_PROG][i]);
> -
> - if (glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][i])
> - dispatch->glDeleteShader(
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_MAIN_PROG][i]);
> -
> - if (glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][i])
> - dispatch->glDeleteShader(
> - glamor_priv->radial_gradient_shaders[SHADER_GRADIENT_FS_GETCOLOR_PROG][i]);
> -
> - if (glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][i])
> - dispatch->glDeleteProgram(glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][i]);
> - }
> -
> - glamor_put_dispatch(glamor_priv);
> -}
> -
> -static void
> -_glamor_gradient_convert_trans_matrix(PictTransform *from, float to[3][3],
> - int width, int height, int normalize)
> -{
> - /*
> - * Because in the shader program, we normalize all the pixel cood to [0, 1],
> - * so with the transform matrix, the correct logic should be:
> - * v_s = A*T*v
> - * v_s: point vector in shader after normalized.
> - * A: The transition matrix from width X height --> 1.0 X 1.0
> - * T: The transform matrix.
> - * v: point vector in width X height space.
> - *
> - * result is OK if we use this fomula. But for every point in width X height space,
> - * we can just use their normalized point vector in shader, namely we can just
> - * use the result of A*v in shader. So we have no chance to insert T in A*v.
> - * We can just convert v_s = A*T*v to v_s = A*T*inv(A)*A*v, where inv(A) is the
> - * inverse matrix of A. Now, v_s = (A*T*inv(A)) * (A*v)
> - * So, to get the correct v_s, we need to cacula1 the matrix: (A*T*inv(A)), and
> - * we name this matrix T_s.
> - *
> - * Firstly, because A is for the scale convertion, we find
> - * -- --
> - * |1/w 0 0 |
> - * A = | 0 1/h 0 |
> - * | 0 0 1.0|
> - * -- --
> - * so T_s = A*T*inv(a) and result
> - *
> - * -- --
> - * | t11 h*t12/w t13/w|
> - * T_s = | w*t21/h t22 t23/h|
> - * | w*t31 h*t32 t33 |
> - * -- --
> - */
> -
> - to[0][0] = (float)pixman_fixed_to_double(from->matrix[0][0]);
> - to[0][1] = (float)pixman_fixed_to_double(from->matrix[0][1])
> - * (normalize ? (((float)height) / ((float)width)) : 1.0);
> - to[0][2] = (float)pixman_fixed_to_double(from->matrix[0][2])
> - / (normalize ? ((float)width) : 1.0);
> -
> - to[1][0] = (float)pixman_fixed_to_double(from->matrix[1][0])
> - * (normalize ? (((float)width) / ((float)height)) : 1.0);
> - to[1][1] = (float)pixman_fixed_to_double(from->matrix[1][1]);
> - to[1][2] = (float)pixman_fixed_to_double(from->matrix[1][2])
> - / (normalize ? ((float)height) : 1.0);
> -
> - to[2][0] = (float)pixman_fixed_to_double(from->matrix[2][0])
> - * (normalize ? ((float)width) : 1.0);
> - to[2][1] = (float)pixman_fixed_to_double(from->matrix[2][1])
> - * (normalize ? ((float)height) : 1.0);
> - to[2][2] = (float)pixman_fixed_to_double(from->matrix[2][2]);
> -
> - DEBUGF("the transform matrix is:\n%f\t%f\t%f\n%f\t%f\t%f\n%f\t%f\t%f\n",
> - to[0][0], to[0][1], to[0][2],
> - to[1][0], to[1][1], to[1][2],
> - to[2][0], to[2][1], to[2][2]);
> -}
> -
> -static int
> -_glamor_gradient_set_pixmap_destination(ScreenPtr screen,
> - glamor_screen_private *glamor_priv,
> - PicturePtr dst_picture,
> - GLfloat *xscale, GLfloat *yscale,
> - int x_source, int y_source,
> - float vertices[8],
> - float tex_vertices[8],
> - int tex_normalize)
> -{
> - glamor_pixmap_private *pixmap_priv;
> - PixmapPtr pixmap = NULL;
> -
> - pixmap = glamor_get_drawable_pixmap(dst_picture->pDrawable);
> - pixmap_priv = glamor_get_pixmap_private(pixmap);
> -
> - if (!GLAMOR_PIXMAP_PRIV_HAS_FBO(pixmap_priv)) { /* should always have here. */
> - return 0;
> - }
> -
> - glamor_set_destination_pixmap_priv_nc(pixmap_priv);
> -
> - pixmap_priv_get_scale(pixmap_priv, xscale, yscale);
> -
> - glamor_priv->has_source_coords = 1;
> - glamor_priv->has_mask_coords = 0;
> - glamor_setup_composite_vbo(screen, 4*2);
> -
> - DEBUGF("xscale = %f, yscale = %f,"
> - " x_source = %d, y_source = %d, width = %d, height = %d\n",
> - *xscale, *yscale, x_source, y_source,
> - dst_picture->pDrawable->width, dst_picture->pDrawable->height);
> -
> - glamor_set_normalize_vcoords(*xscale, *yscale,
> - 0, 0,
> - (INT16)(dst_picture->pDrawable->width),
> - (INT16)(dst_picture->pDrawable->height),
> - glamor_priv->yInverted, vertices);
> -
> - if (tex_normalize) {
> - glamor_set_normalize_tcoords(*xscale, *yscale,
> - 0, 0,
> - (INT16)(dst_picture->pDrawable->width),
> - (INT16)(dst_picture->pDrawable->height),
> - glamor_priv->yInverted, tex_vertices);
> - } else {
> - glamor_set_tcoords(0, 0,
> - (INT16)(dst_picture->pDrawable->width),
> - (INT16)(dst_picture->pDrawable->height),
> - glamor_priv->yInverted, tex_vertices);
> - }
> -
> - DEBUGF("vertices --> leftup : %f X %f, rightup: %f X %f,"
> - "rightbottom: %f X %f, leftbottom : %f X %f\n",
> - vertices[0], vertices[1], vertices[2], vertices[3],
> - vertices[4], vertices[5], vertices[6], vertices[7]);
> - DEBUGF("tex_vertices --> leftup : %f X %f, rightup: %f X %f,"
> - "rightbottom: %f X %f, leftbottom : %f X %f\n",
> - tex_vertices[0], tex_vertices[1], tex_vertices[2], tex_vertices[3],
> - tex_vertices[4], tex_vertices[5], tex_vertices[6], tex_vertices[7]);
> -
> - return 1;
> -}
> -
> -static int
> -_glamor_gradient_set_stops(PicturePtr src_picture, PictGradient * pgradient,
> - GLfloat *stop_colors, GLfloat *n_stops)
> -{
> - int i;
> - int count = 1;
> -
> - for (i = 0; i< pgradient->nstops; i++) {
> - /* We find some gradient picture set the stops at the same percentage, which
> - will cause the shader problem because the (stops[i] - stops[i-1]) will
> - be used as divisor. We just keep the later one if stops[i] == stops[i-1] */
> - if (i< pgradient->nstops - 1
> - && pgradient->stops[i].x == pgradient->stops[i+1].x)
> - continue;
> -
> - stop_colors[count*4] = pixman_fixed_to_double(
> - pgradient->stops[i].color.red);
> - stop_colors[count*4+1] = pixman_fixed_to_double(
> - pgradient->stops[i].color.green);
> - stop_colors[count*4+2] = pixman_fixed_to_double(
> - pgradient->stops[i].color.blue);
> - stop_colors[count*4+3] = pixman_fixed_to_double(
> - pgradient->stops[i].color.alpha);
> -
> - n_stops[count] = (GLfloat)pixman_fixed_to_double(
> - pgradient->stops[i].x);
> - count++;
> - }
> -
> - /* for the end stop. */
> - count++;
> -
> - switch (src_picture->repeatType) {
> -#define REPEAT_FILL_STOPS(m, n) \
> - stop_colors[(m)*4 + 0] = stop_colors[(n)*4 + 0]; \
> - stop_colors[(m)*4 + 1] = stop_colors[(n)*4 + 1]; \
> - stop_colors[(m)*4 + 2] = stop_colors[(n)*4 + 2]; \
> - stop_colors[(m)*4 + 3] = stop_colors[(n)*4 + 3];
> -
> - default:
> - case PIXMAN_REPEAT_NONE:
> - stop_colors[0] = 0.0; //R
> - stop_colors[1] = 0.0; //G
> - stop_colors[2] = 0.0; //B
> - stop_colors[3] = 0.0; //Alpha
> - n_stops[0] = -(float)INT_MAX; //should be small enough.
> -
> - stop_colors[0 + (count-1)*4] = 0.0; //R
> - stop_colors[1 + (count-1)*4] = 0.0; //G
> - stop_colors[2 + (count-1)*4] = 0.0; //B
> - stop_colors[3 + (count-1)*4] = 0.0; //Alpha
> - n_stops[count-1] = (float)INT_MAX; //should be large enough.
> - break;
> - case PIXMAN_REPEAT_NORMAL:
> - REPEAT_FILL_STOPS(0, count - 2);
> - n_stops[0] = n_stops[count-2] - 1.0;
> -
> - REPEAT_FILL_STOPS(count - 1, 1);
> - n_stops[count-1] = n_stops[1] + 1.0;
> - break;
> - case PIXMAN_REPEAT_REFLECT:
> - REPEAT_FILL_STOPS(0, 1);
> - n_stops[0] = -n_stops[1];
> -
> - REPEAT_FILL_STOPS(count - 1, count - 2);
> - n_stops[count-1] = 1.0 + 1.0 - n_stops[count-2];
> - break;
> - case PIXMAN_REPEAT_PAD:
> - REPEAT_FILL_STOPS(0, 1);
> - n_stops[0] = -(float)INT_MAX;
> -
> - REPEAT_FILL_STOPS(count - 1, count - 2);
> - n_stops[count-1] = (float)INT_MAX;
> - break;
> -#undef REPEAT_FILL_STOPS
> - }
> -
> - for (i = 0; i< count; i++) {
> - DEBUGF("n_stops[%d] = %f, color = r:%f g:%f b:%f a:%f\n",
> - i, n_stops[i],
> - stop_colors[i*4], stop_colors[i*4+1],
> - stop_colors[i*4+2], stop_colors[i*4+3]);
> - }
> -
> - return count;
> -}
> -
> -static PicturePtr
> -_glamor_generate_radial_gradient_picture(ScreenPtr screen,
> - PicturePtr src_picture,
> - int x_source, int y_source,
> - int width, int height,
> - PictFormatShort format)
> -{
> - glamor_screen_private *glamor_priv;
> - glamor_gl_dispatch *dispatch;
> - PicturePtr dst_picture = NULL;
> - PixmapPtr pixmap = NULL;
> - GLint gradient_prog = 0;
> - int error;
> - float tex_vertices[8];
> - int stops_count;
> - int count = 0;
> - GLfloat *stop_colors = NULL;
> - GLfloat *n_stops = NULL;
> - GLfloat xscale, yscale;
> - float vertices[8];
> - float transform_mat[3][3];
> - static const float identity_mat[3][3] = {{1.0, 0.0, 0.0},
> - {0.0, 1.0, 0.0},
> - {0.0, 0.0, 1.0}};
> - GLfloat stop_colors_st[RADIAL_SMALL_STOPS*4];
> - GLfloat n_stops_st[RADIAL_SMALL_STOPS];
> - GLfloat A_value;
> - GLfloat cxy[4];
> - float c1x, c1y, c2x, c2y, r1, r2;
> -
> - GLint transform_mat_uniform_location;
> - GLint repeat_type_uniform_location;
> - GLint n_stop_uniform_location;
> - GLint stops_uniform_location;
> - GLint stop_colors_uniform_location;
> - GLint stop0_uniform_location;
> - GLint stop1_uniform_location;
> - GLint stop2_uniform_location;
> - GLint stop3_uniform_location;
> - GLint stop4_uniform_location;
> - GLint stop5_uniform_location;
> - GLint stop6_uniform_location;
> - GLint stop7_uniform_location;
> - GLint stop_color0_uniform_location;
> - GLint stop_color1_uniform_location;
> - GLint stop_color2_uniform_location;
> - GLint stop_color3_uniform_location;
> - GLint stop_color4_uniform_location;
> - GLint stop_color5_uniform_location;
> - GLint stop_color6_uniform_location;
> - GLint stop_color7_uniform_location;
> - GLint A_value_uniform_location;
> - GLint c1_uniform_location;
> - GLint r1_uniform_location;
> - GLint c2_uniform_location;
> - GLint r2_uniform_location;
> -
> - glamor_priv = glamor_get_screen_private(screen);
> - dispatch = glamor_get_dispatch(glamor_priv);
> -
> - /* Create a pixmap with VBO. */
> - pixmap = glamor_create_pixmap(screen,
> - width, height,
> - PIXMAN_FORMAT_DEPTH(format),
> - 0);
> - if (!pixmap)
> - goto GRADIENT_FAIL;
> -
> - dst_picture = CreatePicture(0,&pixmap->drawable,
> - PictureMatchFormat(screen,
> - PIXMAN_FORMAT_DEPTH(format), format),
> - 0, 0, serverClient,&error);
> -
> - /* Release the reference, picture will hold the last one. */
> - glamor_destroy_pixmap(pixmap);
> -
> - if (!dst_picture)
> - goto GRADIENT_FAIL;
> -
> - ValidatePicture(dst_picture);
> -
> - stops_count = src_picture->pSourcePict->radial.nstops + 2;
> -
> - /* Because the max value of nstops is unkown, so create a program
> - when nstops> LINEAR_LARGE_STOPS.*/
> - if (stops_count<= RADIAL_SMALL_STOPS) {
> - gradient_prog = glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][0];
> - } else if (stops_count<= RADIAL_LARGE_STOPS) {
> - gradient_prog = glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][1];
> - } else {
> - _glamor_create_radial_gradient_program(screen, src_picture->pSourcePict->linear.nstops + 2, 1);
> - gradient_prog = glamor_priv->gradient_prog[SHADER_GRADIENT_RADIAL][2];
> - }
> -
> - /* Bind all the uniform vars .*/
> - transform_mat_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "transform_mat");
> - repeat_type_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "repeat_type");
> - n_stop_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "n_stop");
> - A_value_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "A_value");
> - repeat_type_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "repeat_type");
> - c1_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "c1");
> - r1_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "r1");
> - c2_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "c2");
> - r2_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "r2");
> -
> - if (src_picture->pSourcePict->radial.nstops + 2<= RADIAL_SMALL_STOPS) {
> - stop0_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop0");
> - stop1_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop1");
> - stop2_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop2");
> - stop3_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop3");
> - stop4_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop4");
> - stop5_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop5");
> - stop6_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop6");
> - stop7_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop7");
> -
> - stop_color0_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color0");
> - stop_color1_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color1");
> - stop_color2_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color2");
> - stop_color3_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color3");
> - stop_color4_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color4");
> - stop_color5_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color5");
> - stop_color6_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color6");
> - stop_color7_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color7");
> - } else {
> - stops_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stops");
> - stop_colors_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_colors");
> - }
> -
> - dispatch->glUseProgram(gradient_prog);
> -
> - dispatch->glUniform1i(repeat_type_uniform_location, src_picture->repeatType);
> -
> -
> - if (src_picture->transform) {
> - _glamor_gradient_convert_trans_matrix(src_picture->transform,
> - transform_mat,
> - width, height, 0);
> - dispatch->glUniformMatrix3fv(transform_mat_uniform_location,
> - 1, 1,&transform_mat[0][0]);
> - } else {
> - dispatch->glUniformMatrix3fv(transform_mat_uniform_location,
> - 1, 1,&identity_mat[0][0]);
> - }
> -
> - if (!_glamor_gradient_set_pixmap_destination(screen, glamor_priv, dst_picture,
> - &xscale,&yscale, x_source, y_source,
> - vertices, tex_vertices, 0))
> - goto GRADIENT_FAIL;
> -
> - /* Set all the stops and colors to shader. */
> - if (stops_count> RADIAL_SMALL_STOPS) {
> - stop_colors = malloc(4 * stops_count * sizeof(float));
> - if (stop_colors == NULL) {
> - ErrorF("Failed to allocate stop_colors memory.\n");
> - goto GRADIENT_FAIL;
> - }
> -
> - n_stops = malloc(stops_count * sizeof(float));
> - if (n_stops == NULL) {
> - ErrorF("Failed to allocate n_stops memory.\n");
> - goto GRADIENT_FAIL;
> - }
> - } else {
> - stop_colors = stop_colors_st;
> - n_stops = n_stops_st;
> - }
> -
> - count = _glamor_gradient_set_stops(src_picture,&src_picture->pSourcePict->gradient,
> - stop_colors, n_stops);
> -
> - if (src_picture->pSourcePict->linear.nstops + 2<= RADIAL_SMALL_STOPS) {
> - int j = 0;
> - dispatch->glUniform4f(stop_color0_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> - j++;
> - dispatch->glUniform4f(stop_color1_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> - j++;
> - dispatch->glUniform4f(stop_color2_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> - j++;
> - dispatch->glUniform4f(stop_color3_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> - j++;
> - dispatch->glUniform4f(stop_color4_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> - j++;
> - dispatch->glUniform4f(stop_color5_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> - j++;
> - dispatch->glUniform4f(stop_color6_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> - j++;
> - dispatch->glUniform4f(stop_color7_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> -
> - j = 0;
> - dispatch->glUniform1f(stop0_uniform_location, n_stops[j++]);
> - dispatch->glUniform1f(stop1_uniform_location, n_stops[j++]);
> - dispatch->glUniform1f(stop2_uniform_location, n_stops[j++]);
> - dispatch->glUniform1f(stop3_uniform_location, n_stops[j++]);
> - dispatch->glUniform1f(stop4_uniform_location, n_stops[j++]);
> - dispatch->glUniform1f(stop5_uniform_location, n_stops[j++]);
> - dispatch->glUniform1f(stop6_uniform_location, n_stops[j++]);
> - dispatch->glUniform1f(stop7_uniform_location, n_stops[j++]);
> - dispatch->glUniform1i(n_stop_uniform_location, count);
> - } else {
> - dispatch->glUniform4fv(stop_colors_uniform_location, count, stop_colors);
> - dispatch->glUniform1fv(stops_uniform_location, count, n_stops);
> - dispatch->glUniform1i(n_stop_uniform_location, count);
> - }
> -
> - c1x = (float)pixman_fixed_to_double(src_picture->pSourcePict->radial.c1.x);
> - c1y = (float)pixman_fixed_to_double(src_picture->pSourcePict->radial.c1.y);
> - c2x = (float)pixman_fixed_to_double(src_picture->pSourcePict->radial.c2.x);
> - c2y = (float)pixman_fixed_to_double(src_picture->pSourcePict->radial.c2.y);
> -
> - r1 = (float)pixman_fixed_to_double(src_picture->pSourcePict->radial.c1.radius);
> - r2 = (float)pixman_fixed_to_double(src_picture->pSourcePict->radial.c2.radius);
> -
> -
> - cxy[0] = c1x;
> - cxy[1] = c1y;
> - dispatch->glUniform2fv(c1_uniform_location, 1, cxy);
> - dispatch->glUniform1f(r1_uniform_location, r1);
> -
> - cxy[0] = c2x;
> - cxy[1] = c2y;
> - dispatch->glUniform2fv(c2_uniform_location, 1, cxy);
> - dispatch->glUniform1f(r2_uniform_location, r2);
> -
> - A_value = (c2x - c1x) * (c2x - c1x) + (c2y - c1y) * (c2y - c1y) - (r2 - r1) * (r2 - r1);
> - dispatch->glUniform1f(A_value_uniform_location, A_value);
> -
> - DEBUGF("C1:(%f, %f) R1:%f\nC2:(%f, %f) R2:%f\nA = %f\n",
> - c1x, c1y, r1, c2x, c2y, r2, A_value);
> -
> - glamor_emit_composite_rect(screen, tex_vertices, NULL, vertices);
> -
> - if (glamor_priv->render_nr_verts) {
> - if (glamor_priv->gl_flavor == GLAMOR_GL_DESKTOP)
> - dispatch->glUnmapBuffer(GL_ARRAY_BUFFER);
> - else {
> -
> - dispatch->glBindBuffer(GL_ARRAY_BUFFER, glamor_priv->vbo);
> - dispatch->glBufferData(GL_ARRAY_BUFFER,
> - glamor_priv->vbo_offset,
> - glamor_priv->vb, GL_DYNAMIC_DRAW);
> - }
> -
> - dispatch->glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, NULL);
> - }
> -
> -
> - /* Do the clear logic.*/
> - if (stops_count> RADIAL_SMALL_STOPS) {
> - free(n_stops);
> - free(stop_colors);
> - }
> -
> - dispatch->glBindBuffer(GL_ARRAY_BUFFER, 0);
> - dispatch->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
> -
> - dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
> - dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
> - dispatch->glUseProgram(0);
> -
> - glamor_put_dispatch(glamor_priv);
> - return dst_picture;
> -
> -GRADIENT_FAIL:
> - if (dst_picture) {
> - FreePicture(dst_picture, 0);
> - }
> -
> - if (stops_count> RADIAL_SMALL_STOPS) {
> - if (n_stops)
> - free(n_stops);
> - if (stop_colors)
> - free(stop_colors);
> - }
> -
> - dispatch->glBindBuffer(GL_ARRAY_BUFFER, 0);
> - dispatch->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
> -
> - dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
> - dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
> - dispatch->glUseProgram(0);
> - glamor_put_dispatch(glamor_priv);
> - return NULL;
> -}
> -
> -static PicturePtr
> -_glamor_generate_linear_gradient_picture(ScreenPtr screen,
> - PicturePtr src_picture,
> - int x_source, int y_source,
> - int width, int height,
> - PictFormatShort format)
> -{
> - glamor_screen_private *glamor_priv;
> - glamor_gl_dispatch *dispatch;
> - PicturePtr dst_picture = NULL;
> - PixmapPtr pixmap = NULL;
> - GLint gradient_prog = 0;
> - int error;
> - float pt_distance;
> - float p1_distance;
> - GLfloat cos_val;
> - float tex_vertices[8];
> - int stops_count;
> - GLfloat *stop_colors = NULL;
> - GLfloat *n_stops = NULL;
> - int count = 0;
> - float slope;
> - GLfloat xscale, yscale;
> - GLfloat pt1[4], pt2[4];
> - float vertices[8];
> - float transform_mat[3][3];
> - static const float identity_mat[3][3] = {{1.0, 0.0, 0.0},
> - {0.0, 1.0, 0.0},
> - {0.0, 0.0, 1.0}};
> - GLfloat stop_colors_st[LINEAR_SMALL_STOPS*4];
> - GLfloat n_stops_st[LINEAR_SMALL_STOPS];
> -
> - GLint transform_mat_uniform_location;
> - GLint pt1_uniform_location;
> - GLint pt2_uniform_location;
> - GLint n_stop_uniform_location;
> - GLint stops_uniform_location;
> - GLint stop0_uniform_location;
> - GLint stop1_uniform_location;
> - GLint stop2_uniform_location;
> - GLint stop3_uniform_location;
> - GLint stop4_uniform_location;
> - GLint stop5_uniform_location;
> - GLint stop6_uniform_location;
> - GLint stop7_uniform_location;
> - GLint stop_colors_uniform_location;
> - GLint stop_color0_uniform_location;
> - GLint stop_color1_uniform_location;
> - GLint stop_color2_uniform_location;
> - GLint stop_color3_uniform_location;
> - GLint stop_color4_uniform_location;
> - GLint stop_color5_uniform_location;
> - GLint stop_color6_uniform_location;
> - GLint stop_color7_uniform_location;
> - GLint pt_slope_uniform_location;
> - GLint repeat_type_uniform_location;
> - GLint hor_ver_uniform_location;
> - GLint cos_val_uniform_location;
> - GLint p1_distance_uniform_location;
> - GLint pt_distance_uniform_location;
> -
> - glamor_priv = glamor_get_screen_private(screen);
> - dispatch = glamor_get_dispatch(glamor_priv);
> -
> - /* Create a pixmap with VBO. */
> - pixmap = glamor_create_pixmap(screen,
> - width, height,
> - PIXMAN_FORMAT_DEPTH(format),
> - 0);
> -
> - if (!pixmap)
> - goto GRADIENT_FAIL;
> -
> - dst_picture = CreatePicture(0,&pixmap->drawable,
> - PictureMatchFormat(screen,
> - PIXMAN_FORMAT_DEPTH(format), format),
> - 0, 0, serverClient,&error);
> -
> - /* Release the reference, picture will hold the last one. */
> - glamor_destroy_pixmap(pixmap);
> -
> - if (!dst_picture)
> - goto GRADIENT_FAIL;
> -
> - ValidatePicture(dst_picture);
> -
> - stops_count = src_picture->pSourcePict->linear.nstops + 2;
> -
> - /* Because the max value of nstops is unkown, so create a program
> - when nstops> LINEAR_LARGE_STOPS.*/
> - if (stops_count<= LINEAR_SMALL_STOPS) {
> - gradient_prog = glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][0];
> - } else if (stops_count<= LINEAR_LARGE_STOPS) {
> - gradient_prog = glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][1];
> - } else {
> - _glamor_create_linear_gradient_program(screen,
> - src_picture->pSourcePict->linear.nstops + 2, 1);
> - gradient_prog = glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][2];
> - }
> -
> - /* Bind all the uniform vars .*/
> - pt1_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "pt1");
> - pt2_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "pt2");
> - n_stop_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "n_stop");
> - pt_slope_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "pt_slope");
> - repeat_type_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "repeat_type");
> - hor_ver_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "hor_ver");
> - transform_mat_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "transform_mat");
> - cos_val_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "cos_val");
> - p1_distance_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "p1_distance");
> - pt_distance_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "pt_distance");
> -
> - if (src_picture->pSourcePict->linear.nstops + 2<= LINEAR_SMALL_STOPS) {
> - stop0_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop0");
> - stop1_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop1");
> - stop2_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop2");
> - stop3_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop3");
> - stop4_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop4");
> - stop5_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop5");
> - stop6_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop6");
> - stop7_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop7");
> -
> - stop_color0_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color0");
> - stop_color1_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color1");
> - stop_color2_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color2");
> - stop_color3_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color3");
> - stop_color4_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color4");
> - stop_color5_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color5");
> - stop_color6_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color6");
> - stop_color7_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_color7");
> - } else {
> - stops_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stops");
> - stop_colors_uniform_location =
> - dispatch->glGetUniformLocation(gradient_prog, "stop_colors");
> - }
> -
> - dispatch->glUseProgram(gradient_prog);
> -
> - dispatch->glUniform1i(repeat_type_uniform_location, src_picture->repeatType);
> -
> - if (src_picture->transform) {
> - _glamor_gradient_convert_trans_matrix(src_picture->transform,
> - transform_mat,
> - width, height, 1);
> - dispatch->glUniformMatrix3fv(transform_mat_uniform_location,
> - 1, 1,&transform_mat[0][0]);
> - } else {
> - dispatch->glUniformMatrix3fv(transform_mat_uniform_location,
> - 1, 1,&identity_mat[0][0]);
> - }
> -
> - if (!_glamor_gradient_set_pixmap_destination(screen, glamor_priv, dst_picture,
> - &xscale,&yscale, x_source, y_source,
> - vertices, tex_vertices, 1))
> - goto GRADIENT_FAIL;
> -
> - /* Normalize the PTs. */
> - glamor_set_normalize_pt(xscale, yscale,
> - pixman_fixed_to_int(src_picture->pSourcePict->linear.p1.x),
> - x_source,
> - pixman_fixed_to_int(src_picture->pSourcePict->linear.p1.y),
> - y_source,
> - glamor_priv->yInverted,
> - pt1);
> - dispatch->glUniform4fv(pt1_uniform_location, 1, pt1);
> - DEBUGF("pt1:(%f %f)\n", pt1[0], pt1[1]);
> -
> - glamor_set_normalize_pt(xscale, yscale,
> - pixman_fixed_to_int(src_picture->pSourcePict->linear.p2.x),
> - x_source,
> - pixman_fixed_to_int(src_picture->pSourcePict->linear.p2.y),
> - y_source,
> - glamor_priv->yInverted,
> - pt2);
> - dispatch->glUniform4fv(pt2_uniform_location, 1, pt2);
> - DEBUGF("pt2:(%f %f)\n", pt2[0], pt2[1]);
> -
> - /* Set all the stops and colors to shader. */
> - if (stops_count> LINEAR_SMALL_STOPS) {
> - stop_colors = malloc(4 * stops_count * sizeof(float));
> - if (stop_colors == NULL) {
> - ErrorF("Failed to allocate stop_colors memory.\n");
> - goto GRADIENT_FAIL;
> - }
> -
> - n_stops = malloc(stops_count * sizeof(float));
> - if (n_stops == NULL) {
> - ErrorF("Failed to allocate n_stops memory.\n");
> - goto GRADIENT_FAIL;
> - }
> - } else {
> - stop_colors = stop_colors_st;
> - n_stops = n_stops_st;
> - }
> -
> - count = _glamor_gradient_set_stops(src_picture,&src_picture->pSourcePict->gradient,
> - stop_colors, n_stops);
> -
> - if (src_picture->pSourcePict->linear.nstops + 2<= LINEAR_SMALL_STOPS) {
> - int j = 0;
> - dispatch->glUniform4f(stop_color0_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> - j++;
> - dispatch->glUniform4f(stop_color1_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> - j++;
> - dispatch->glUniform4f(stop_color2_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> - j++;
> - dispatch->glUniform4f(stop_color3_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> - j++;
> - dispatch->glUniform4f(stop_color4_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> - j++;
> - dispatch->glUniform4f(stop_color5_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> - j++;
> - dispatch->glUniform4f(stop_color6_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> - j++;
> - dispatch->glUniform4f(stop_color7_uniform_location, stop_colors[4*j+0], stop_colors[4*j+1],
> - stop_colors[4*j+2], stop_colors[4*j+3]);
> -
> - j = 0;
> - dispatch->glUniform1f(stop0_uniform_location, n_stops[j++]);
> - dispatch->glUniform1f(stop1_uniform_location, n_stops[j++]);
> - dispatch->glUniform1f(stop2_uniform_location, n_stops[j++]);
> - dispatch->glUniform1f(stop3_uniform_location, n_stops[j++]);
> - dispatch->glUniform1f(stop4_uniform_location, n_stops[j++]);
> - dispatch->glUniform1f(stop5_uniform_location, n_stops[j++]);
> - dispatch->glUniform1f(stop6_uniform_location, n_stops[j++]);
> - dispatch->glUniform1f(stop7_uniform_location, n_stops[j++]);
> -
> - dispatch->glUniform1i(n_stop_uniform_location, count);
> - } else {
> - dispatch->glUniform4fv(stop_colors_uniform_location, count, stop_colors);
> - dispatch->glUniform1fv(stops_uniform_location, count, n_stops);
> - dispatch->glUniform1i(n_stop_uniform_location, count);
> - }
> -
> - if ((pt2[1] - pt1[1]) / yscale< 1.0) { // The horizontal case.
> - dispatch->glUniform1i(hor_ver_uniform_location, 1);
> - DEBUGF("p1.x: %f, p2.x: %f, enter the horizontal case\n", pt1[1], pt2[1]);
> -
> - p1_distance = pt1[0];
> - pt_distance = (pt2[0] - p1_distance);
> - dispatch->glUniform1f(p1_distance_uniform_location, p1_distance);
> - dispatch->glUniform1f(pt_distance_uniform_location, pt_distance);
> - } else if ((pt2[0] - pt1[0]) / xscale< 1.0) { //The vertical case.
> - dispatch->glUniform1i(hor_ver_uniform_location, 2);
> - DEBUGF("p1.y: %f, p2.y: %f, enter the vertical case\n", pt1[0], pt2[0]);
> -
> - p1_distance = pt1[1];
> - pt_distance = (pt2[1] - p1_distance);
> - dispatch->glUniform1f(p1_distance_uniform_location, p1_distance);
> - dispatch->glUniform1f(pt_distance_uniform_location, pt_distance);
> - } else {
> - /* The slope need to compute here. In shader, the viewport set will change
> - the orginal slope and the slope which is vertical to it will not be correct.*/
> - slope = - (float)(src_picture->pSourcePict->linear.p2.x - src_picture->pSourcePict->linear.p1.x) /
> - (float)(src_picture->pSourcePict->linear.p2.y - src_picture->pSourcePict->linear.p1.y);
> - slope = slope * yscale / xscale;
> - dispatch->glUniform1f(pt_slope_uniform_location, slope);
> - dispatch->glUniform1i(hor_ver_uniform_location, 0);
> -
> - cos_val = sqrt(1.0 / (slope * slope + 1.0));
> - dispatch->glUniform1f(cos_val_uniform_location, cos_val);
> -
> - p1_distance = (pt1[1] - pt1[0] * slope) * cos_val;
> - pt_distance = (pt2[1] - pt2[0] * slope) * cos_val - p1_distance;
> - dispatch->glUniform1f(p1_distance_uniform_location, p1_distance);
> - dispatch->glUniform1f(pt_distance_uniform_location, pt_distance);
> - }
> -
> - /* set the transform matrix. */ /* Now rendering. */
> - glamor_emit_composite_rect(screen, tex_vertices, NULL, vertices);
> -
> - if (glamor_priv->render_nr_verts) {
> - if (glamor_priv->gl_flavor == GLAMOR_GL_DESKTOP)
> - dispatch->glUnmapBuffer(GL_ARRAY_BUFFER);
> - else {
> -
> - dispatch->glBindBuffer(GL_ARRAY_BUFFER, glamor_priv->vbo);
> - dispatch->glBufferData(GL_ARRAY_BUFFER,
> - glamor_priv->vbo_offset,
> - glamor_priv->vb, GL_DYNAMIC_DRAW);
> - }
> -
> - dispatch->glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, NULL);
> - }
> -
> - /* Do the clear logic.*/
> - if (stops_count> LINEAR_SMALL_STOPS) {
> - free(n_stops);
> - free(stop_colors);
> - }
> -
> - dispatch->glBindBuffer(GL_ARRAY_BUFFER, 0);
> - dispatch->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
> -
> - dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
> - dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
> - dispatch->glUseProgram(0);
> -
> - glamor_put_dispatch(glamor_priv);
> - return dst_picture;
> -
> -GRADIENT_FAIL:
> - if (dst_picture) {
> - FreePicture(dst_picture, 0);
> - }
> -
> - if (stops_count> LINEAR_SMALL_STOPS) {
> - if (n_stops)
> - free(n_stops);
> - if (stop_colors)
> - free(stop_colors);
> - }
> -
> - dispatch->glBindBuffer(GL_ARRAY_BUFFER, 0);
> - dispatch->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
> -
> - dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
> - dispatch->glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
> - dispatch->glUseProgram(0);
> - glamor_put_dispatch(glamor_priv);
> - return NULL;
> -}
> -#undef LINEAR_DEFAULT_STOPS
> -#endif
> -
> static PicturePtr
> glamor_convert_gradient_picture(ScreenPtr screen,
> PicturePtr source,
> @@ -2933,10 +1355,10 @@ glamor_convert_gradient_picture(ScreenPtr screen,
> #ifdef GLAMOR_GRADIENT_SHADER
> if (!source->pDrawable) {
> if (source->pSourcePict->type == SourcePictTypeLinear) {
> - dst = _glamor_generate_linear_gradient_picture(screen,
> + dst = glamor_generate_linear_gradient_picture(screen,
> source, x_source, y_source, width, height, format);
> } else if (source->pSourcePict->type == SourcePictTypeRadial) {
> - dst = _glamor_generate_radial_gradient_picture(screen,
> + dst = glamor_generate_radial_gradient_picture(screen,
> source, x_source, y_source, width, height, format);
> }
>
> @@ -3021,6 +1443,11 @@ _glamor_composite(CARD8 op,
> x_temp_mask = x_mask;
> y_temp_mask = y_mask;
>
> + DEBUGF("Composite Src: (%d, %d)\n"
> + " Mask: (%d, %d)\n"
> + " to dst: (%d, %d), size: %d X %d \n",
> + x_source, y_source, x_mask, y_mask, x_dest, y_dest, width, height);
> +
> dest_pixmap_priv = glamor_get_pixmap_private(dest_pixmap);
> /* Currently. Always fallback to cpu if destination is in CPU memory. */
>
More information about the Glamor
mailing list