Subversion Repositories Kolibri OS

Rev

Rev 1891 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1891 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,
3931 Serge 34
                              pixman_repeat_t		repeat)
1891 serge 35
{
36
    walker->num_stops = gradient->n_stops;
37
    walker->stops     = gradient->stops;
38
    walker->left_x    = 0;
39
    walker->right_x   = 0x10000;
3931 Serge 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;
1891 serge 49
 
50
    walker->need_reset = TRUE;
51
}
52
 
3931 Serge 53
static void
54
gradient_walker_reset (pixman_gradient_walker_t *walker,
55
		       pixman_fixed_48_16_t      pos)
1891 serge 56
{
57
    int32_t x, left_x, right_x;
3931 Serge 58
    pixman_color_t *left_c, *right_c;
1891 serge 59
    int n, count = walker->num_stops;
3931 Serge 60
    pixman_gradient_stop_t *stops = walker->stops;
61
    float la, lr, lg, lb;
62
    float ra, rr, rg, rb;
63
    float lx, rx;
1891 serge 64
 
3931 Serge 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;
1891 serge 91
 
3931 Serge 92
    if (walker->repeat == PIXMAN_REPEAT_NORMAL)
1891 serge 93
    {
94
	left_x  += (pos - x);
95
	right_x += (pos - x);
3931 Serge 96
    }
97
    else if (walker->repeat == PIXMAN_REPEAT_REFLECT)
98
    {
1891 serge 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);
3931 Serge 116
    }
117
    else if (walker->repeat == PIXMAN_REPEAT_NONE)
118
    {
1891 serge 119
	if (n == 0)
3931 Serge 120
	    right_c = left_c;
1891 serge 121
	else if (n == count)
3931 Serge 122
	    left_c = right_c;
1891 serge 123
    }
124
 
3931 Serge 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));
1891 serge 134
 
3931 Serge 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)
1891 serge 144
    {
3931 Serge 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;
1891 serge 150
    }
151
    else
152
    {
3931 Serge 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);
1891 serge 164
    }
3931 Serge 165
 
166
    walker->left_x = left_x;
167
    walker->right_x = right_x;
1891 serge 168
 
169
    walker->need_reset = FALSE;
170
}
171
 
172
uint32_t
173
_pixman_gradient_walker_pixel (pixman_gradient_walker_t *walker,
3931 Serge 174
                               pixman_fixed_48_16_t      x)
1891 serge 175
{
3931 Serge 176
    float a, r, g, b;
177
    uint8_t a8, r8, g8, b8;
178
    uint32_t v;
179
    float y;
1891 serge 180
 
3931 Serge 181
    if (walker->need_reset || x < walker->left_x || x >= walker->right_x)
182
        gradient_walker_reset (walker, x);
1891 serge 183
 
3931 Serge 184
    y = x * (1.0f / 65536.0f);
1891 serge 185
 
3931 Serge 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);
1891 serge 190
 
3931 Serge 191
    a8 = a + 0.5f;
192
    r8 = r + 0.5f;
193
    g8 = g + 0.5f;
194
    b8 = b + 0.5f;
1891 serge 195
 
3931 Serge 196
    v = ((a8 << 24) & 0xff000000) |
197
        ((r8 << 16) & 0x00ff0000) |
198
        ((g8 <<  8) & 0x0000ff00) |
199
        ((b8 >>  0) & 0x000000ff);
1891 serge 200
 
3931 Serge 201
    return v;
1891 serge 202
}