/* * 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 * */ /** @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; #define 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"\ " if(stops[i] - stops[i-1] > 2.0)\n"\ " percentage = 0.0;\n" /*For comply with pixman, walker->stepper overflow.*/\ " else if(stops[i] - stops[i-1] < 0.000001)\n"\ " percentage = 0.0;\n"\ " else \n"\ " percentage = (stop_len - stops[i-1])/(stops[i] - stops[i-1]);\n"\ " 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" " } 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" " } 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" " } 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" " } 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" " } 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" " } 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" " } 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" " } else {\n" " stop_color_before = stop_color7;\n" " stop_color_after = stop_color7;\n" " stop_after = stop7;\n" " stop_before = stop7;\n" " }\n" " if(stop_after - stop_before > 2.0)\n" " percentage = 0.0;\n"//For comply with pixman, walker->stepper overflow. " else if(stop_after - stop_before < 0.000001)\n" " percentage = 0.0;\n" " else \n" " percentage = (stop_len - stop_before)/(stop_after - stop_before);\n" " 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) */ #define gradient_radial_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"\ " 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*/\ " t = fract(t);\n"\ " }\n"\ " \n"\ " if(repeat_type == %d) {\n" /* repeat reflect*/\ " t = abs(fract(t * 0.5 + 0.5) * 2.0 - 1.0);\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->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_radial_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->glDeleteShader(vs_prog); dispatch->glDeleteShader(fs_getcolor_prog); dispatch->glDeleteShader(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); 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_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. */ #define gradient_fs_template \ GLAMOR_DEFAULT_PRECISION\ "uniform mat3 transform_mat;\n"\ "uniform int repeat_type;\n"\ "uniform int hor_ver;\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"\ " 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"\ " } \n"\ " \n"\ " distance = distance - _p1_distance; \n"\ " \n"\ " if(repeat_type == %d){\n" /* repeat normal*/\ " distance = mod(distance, _pt_distance);\n"\ " }\n"\ " \n"\ " if(repeat_type == %d) {\n" /* repeat reflect*/\ " distance = abs(mod(distance + _pt_distance, 2.0 * _pt_distance) - _pt_distance);\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->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->glDeleteShader(vs_prog); dispatch->glDeleteShader(fs_getcolor_prog); dispatch->glDeleteShader(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); 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_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->gradient_prog[SHADER_GRADIENT_RADIAL][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->gradient_prog[SHADER_GRADIENT_LINEAR][i]) dispatch->glDeleteProgram(glamor_priv->gradient_prog[SHADER_GRADIENT_LINEAR][i]); /* Radial Gradient */ 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; 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_dest_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_tri_strip(*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_tri_stripe(*xscale, *yscale, x_source, y_source, (INT16)(dst_picture->pDrawable->width + x_source), (INT16)(dst_picture->pDrawable->height + y_source), glamor_priv->yInverted, tex_vertices); } else { glamor_set_tcoords_tri_strip((INT16)(dst_picture->pDrawable->width), (INT16)(dst_picture->pDrawable->height), x_source, y_source, (INT16)(dst_picture->pDrawable->width) + x_source, (INT16)(dst_picture->pDrawable->height) + y_source, 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]); 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++) { 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); glamor_set_circle_centre(width, height, c1x, c1y, glamor_priv->yInverted, cxy); dispatch->glUniform2fv(c1_uniform_location, 1, cxy); dispatch->glUniform1f(r1_uniform_location, r1); glamor_set_circle_centre(width, height, c2x, c2y, glamor_priv->yInverted, cxy); 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); 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); 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[2], pt2[2]; 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 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 .*/ 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_double(src_picture->pSourcePict->linear.p1.x), pixman_fixed_to_double(src_picture->pSourcePict->linear.p1.y), glamor_priv->yInverted, pt1); DEBUGF("pt1:(%f, %f) ---> (%f %f)\n", pixman_fixed_to_double(src_picture->pSourcePict->linear.p1.x), pixman_fixed_to_double(src_picture->pSourcePict->linear.p1.y), pt1[0], pt1[1]); glamor_set_normalize_pt(xscale, yscale, pixman_fixed_to_double(src_picture->pSourcePict->linear.p2.x), pixman_fixed_to_double(src_picture->pSourcePict->linear.p2.y), glamor_priv->yInverted, pt2); DEBUGF("pt2:(%f, %f) ---> (%f %f)\n", pixman_fixed_to_double(src_picture->pSourcePict->linear.p2.x), pixman_fixed_to_double(src_picture->pSourcePict->linear.p2.y), 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 (src_picture->pSourcePict->linear.p2.y == src_picture->pSourcePict->linear.p1.y) { // The horizontal case. dispatch->glUniform1i(hor_ver_uniform_location, 1); DEBUGF("p1.y: %f, p2.y: %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 { /* 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); 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); glamor_put_dispatch(glamor_priv); return NULL; } #endif /* End of GLAMOR_GRADIENT_SHADER */ #endif /* End of RENDER */