Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4349 | Serge | 1 | /* |
2 | * |
||
3 | * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. |
||
4 | * 2005 Lars Knoll & Zack Rusin, Trolltech |
||
5 | * |
||
6 | * Permission to use, copy, modify, distribute, and sell this software and its |
||
7 | * documentation for any purpose is hereby granted without fee, provided that |
||
8 | * the above copyright notice appear in all copies and that both that |
||
9 | * copyright notice and this permission notice appear in supporting |
||
10 | * documentation, and that the name of Keith Packard not be used in |
||
11 | * advertising or publicity pertaining to distribution of the software without |
||
12 | * specific, written prior permission. Keith Packard makes no |
||
13 | * representations about the suitability of this software for any purpose. It |
||
14 | * is provided "as is" without express or implied warranty. |
||
15 | * |
||
16 | * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS |
||
17 | * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND |
||
18 | * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY |
||
19 | * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
||
20 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN |
||
21 | * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING |
||
22 | * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS |
||
23 | * SOFTWARE. |
||
24 | */ |
||
25 | |||
26 | #ifdef HAVE_CONFIG_H |
||
27 | #include |
||
28 | #endif |
||
29 | #include "pixman-private.h" |
||
30 | |||
31 | void |
||
32 | _pixman_gradient_walker_init (pixman_gradient_walker_t *walker, |
||
33 | gradient_t * gradient, |
||
34 | pixman_repeat_t repeat) |
||
35 | { |
||
36 | walker->num_stops = gradient->n_stops; |
||
37 | walker->stops = gradient->stops; |
||
38 | walker->left_x = 0; |
||
39 | walker->right_x = 0x10000; |
||
40 | walker->a_s = 0.0f; |
||
41 | walker->a_b = 0.0f; |
||
42 | walker->r_s = 0.0f; |
||
43 | walker->r_b = 0.0f; |
||
44 | walker->g_s = 0.0f; |
||
45 | walker->g_b = 0.0f; |
||
46 | walker->b_s = 0.0f; |
||
47 | walker->b_b = 0.0f; |
||
48 | walker->repeat = repeat; |
||
49 | |||
50 | walker->need_reset = TRUE; |
||
51 | } |
||
52 | |||
53 | static void |
||
54 | gradient_walker_reset (pixman_gradient_walker_t *walker, |
||
55 | pixman_fixed_48_16_t pos) |
||
56 | { |
||
57 | int32_t x, left_x, right_x; |
||
58 | pixman_color_t *left_c, *right_c; |
||
59 | int n, count = walker->num_stops; |
||
60 | pixman_gradient_stop_t *stops = walker->stops; |
||
61 | float la, lr, lg, lb; |
||
62 | float ra, rr, rg, rb; |
||
63 | float lx, rx; |
||
64 | |||
65 | if (walker->repeat == PIXMAN_REPEAT_NORMAL) |
||
66 | { |
||
67 | x = (int32_t)pos & 0xffff; |
||
68 | } |
||
69 | else if (walker->repeat == PIXMAN_REPEAT_REFLECT) |
||
70 | { |
||
71 | x = (int32_t)pos & 0xffff; |
||
72 | if ((int32_t)pos & 0x10000) |
||
73 | x = 0x10000 - x; |
||
74 | } |
||
75 | else |
||
76 | { |
||
77 | x = pos; |
||
78 | } |
||
79 | |||
80 | for (n = 0; n < count; n++) |
||
81 | { |
||
82 | if (x < stops[n].x) |
||
83 | break; |
||
84 | } |
||
85 | |||
86 | left_x = stops[n - 1].x; |
||
87 | left_c = &stops[n - 1].color; |
||
88 | |||
89 | right_x = stops[n].x; |
||
90 | right_c = &stops[n].color; |
||
91 | |||
92 | if (walker->repeat == PIXMAN_REPEAT_NORMAL) |
||
93 | { |
||
94 | left_x += (pos - x); |
||
95 | right_x += (pos - x); |
||
96 | } |
||
97 | else if (walker->repeat == PIXMAN_REPEAT_REFLECT) |
||
98 | { |
||
99 | if ((int32_t)pos & 0x10000) |
||
100 | { |
||
101 | pixman_color_t *tmp_c; |
||
102 | int32_t tmp_x; |
||
103 | |||
104 | tmp_x = 0x10000 - right_x; |
||
105 | right_x = 0x10000 - left_x; |
||
106 | left_x = tmp_x; |
||
107 | |||
108 | tmp_c = right_c; |
||
109 | right_c = left_c; |
||
110 | left_c = tmp_c; |
||
111 | |||
112 | x = 0x10000 - x; |
||
113 | } |
||
114 | left_x += (pos - x); |
||
115 | right_x += (pos - x); |
||
116 | } |
||
117 | else if (walker->repeat == PIXMAN_REPEAT_NONE) |
||
118 | { |
||
119 | if (n == 0) |
||
120 | right_c = left_c; |
||
121 | else if (n == count) |
||
122 | left_c = right_c; |
||
123 | } |
||
124 | |||
125 | /* The alpha channel is scaled to be in the [0, 255] interval, |
||
126 | * and the red/green/blue channels are scaled to be in [0, 1]. |
||
127 | * This ensures that after premultiplication all channels will |
||
128 | * be in the [0, 255] interval. |
||
129 | */ |
||
130 | la = (left_c->alpha * (1.0f/257.0f)); |
||
131 | lr = (left_c->red * (1.0f/257.0f)); |
||
132 | lg = (left_c->green * (1.0f/257.0f)); |
||
133 | lb = (left_c->blue * (1.0f/257.0f)); |
||
134 | |||
135 | ra = (right_c->alpha * (1.0f/257.0f)); |
||
136 | rr = (right_c->red * (1.0f/257.0f)); |
||
137 | rg = (right_c->green * (1.0f/257.0f)); |
||
138 | rb = (right_c->blue * (1.0f/257.0f)); |
||
139 | |||
140 | lx = left_x * (1.0f/65536.0f); |
||
141 | rx = right_x * (1.0f/65536.0f); |
||
142 | |||
143 | if (FLOAT_IS_ZERO (rx - lx) || left_x == INT32_MIN || right_x == INT32_MAX) |
||
144 | { |
||
145 | walker->a_s = walker->r_s = walker->g_s = walker->b_s = 0.0f; |
||
146 | walker->a_b = (la + ra) / 2.0f; |
||
147 | walker->r_b = (lr + rr) / 510.0f; |
||
148 | walker->g_b = (lg + rg) / 510.0f; |
||
149 | walker->b_b = (lb + rb) / 510.0f; |
||
150 | } |
||
151 | else |
||
152 | { |
||
153 | float w_rec = 1.0f / (rx - lx); |
||
154 | |||
155 | walker->a_b = (la * rx - ra * lx) * w_rec; |
||
156 | walker->r_b = (lr * rx - rr * lx) * w_rec * (1.0f/255.0f); |
||
157 | walker->g_b = (lg * rx - rg * lx) * w_rec * (1.0f/255.0f); |
||
158 | walker->b_b = (lb * rx - rb * lx) * w_rec * (1.0f/255.0f); |
||
159 | |||
160 | walker->a_s = (ra - la) * w_rec; |
||
161 | walker->r_s = (rr - lr) * w_rec * (1.0f/255.0f); |
||
162 | walker->g_s = (rg - lg) * w_rec * (1.0f/255.0f); |
||
163 | walker->b_s = (rb - lb) * w_rec * (1.0f/255.0f); |
||
164 | } |
||
165 | |||
166 | walker->left_x = left_x; |
||
167 | walker->right_x = right_x; |
||
168 | |||
169 | walker->need_reset = FALSE; |
||
170 | } |
||
171 | |||
172 | uint32_t |
||
173 | _pixman_gradient_walker_pixel (pixman_gradient_walker_t *walker, |
||
174 | pixman_fixed_48_16_t x) |
||
175 | { |
||
176 | float a, r, g, b; |
||
177 | uint8_t a8, r8, g8, b8; |
||
178 | uint32_t v; |
||
179 | float y; |
||
180 | |||
181 | if (walker->need_reset || x < walker->left_x || x >= walker->right_x) |
||
182 | gradient_walker_reset (walker, x); |
||
183 | |||
184 | y = x * (1.0f / 65536.0f); |
||
185 | |||
186 | a = walker->a_s * y + walker->a_b; |
||
187 | r = a * (walker->r_s * y + walker->r_b); |
||
188 | g = a * (walker->g_s * y + walker->g_b); |
||
189 | b = a * (walker->b_s * y + walker->b_b); |
||
190 | |||
191 | a8 = a + 0.5f; |
||
192 | r8 = r + 0.5f; |
||
193 | g8 = g + 0.5f; |
||
194 | b8 = b + 0.5f; |
||
195 | |||
196 | v = ((a8 << 24) & 0xff000000) | |
||
197 | ((r8 << 16) & 0x00ff0000) | |
||
198 | ((g8 << 8) & 0x0000ff00) | |
||
199 | ((b8 >> 0) & 0x000000ff); |
||
200 | |||
201 | return v; |
||
202 | }><>><>><>>>> |