mirror of
https://github.com/KolibriOS/kolibrios.git
synced 2024-12-15 11:22:34 +03:00
754f9336f0
git-svn-id: svn://kolibrios.org@4349 a494cfbc-eb01-0410-851d-a64ba20cac60
203 lines
5.6 KiB
C
203 lines
5.6 KiB
C
/*
|
|
*
|
|
* Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
|
|
* 2005 Lars Knoll & Zack Rusin, Trolltech
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation, and that the name of Keith Packard not be used in
|
|
* advertising or publicity pertaining to distribution of the software without
|
|
* specific, written prior permission. Keith Packard makes no
|
|
* representations about the suitability of this software for any purpose. It
|
|
* is provided "as is" without express or implied warranty.
|
|
*
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
|
|
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
|
|
* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
|
|
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
#include "pixman-private.h"
|
|
|
|
void
|
|
_pixman_gradient_walker_init (pixman_gradient_walker_t *walker,
|
|
gradient_t * gradient,
|
|
pixman_repeat_t repeat)
|
|
{
|
|
walker->num_stops = gradient->n_stops;
|
|
walker->stops = gradient->stops;
|
|
walker->left_x = 0;
|
|
walker->right_x = 0x10000;
|
|
walker->a_s = 0.0f;
|
|
walker->a_b = 0.0f;
|
|
walker->r_s = 0.0f;
|
|
walker->r_b = 0.0f;
|
|
walker->g_s = 0.0f;
|
|
walker->g_b = 0.0f;
|
|
walker->b_s = 0.0f;
|
|
walker->b_b = 0.0f;
|
|
walker->repeat = repeat;
|
|
|
|
walker->need_reset = TRUE;
|
|
}
|
|
|
|
static void
|
|
gradient_walker_reset (pixman_gradient_walker_t *walker,
|
|
pixman_fixed_48_16_t pos)
|
|
{
|
|
int32_t x, left_x, right_x;
|
|
pixman_color_t *left_c, *right_c;
|
|
int n, count = walker->num_stops;
|
|
pixman_gradient_stop_t *stops = walker->stops;
|
|
float la, lr, lg, lb;
|
|
float ra, rr, rg, rb;
|
|
float lx, rx;
|
|
|
|
if (walker->repeat == PIXMAN_REPEAT_NORMAL)
|
|
{
|
|
x = (int32_t)pos & 0xffff;
|
|
}
|
|
else if (walker->repeat == PIXMAN_REPEAT_REFLECT)
|
|
{
|
|
x = (int32_t)pos & 0xffff;
|
|
if ((int32_t)pos & 0x10000)
|
|
x = 0x10000 - x;
|
|
}
|
|
else
|
|
{
|
|
x = pos;
|
|
}
|
|
|
|
for (n = 0; n < count; n++)
|
|
{
|
|
if (x < stops[n].x)
|
|
break;
|
|
}
|
|
|
|
left_x = stops[n - 1].x;
|
|
left_c = &stops[n - 1].color;
|
|
|
|
right_x = stops[n].x;
|
|
right_c = &stops[n].color;
|
|
|
|
if (walker->repeat == PIXMAN_REPEAT_NORMAL)
|
|
{
|
|
left_x += (pos - x);
|
|
right_x += (pos - x);
|
|
}
|
|
else if (walker->repeat == PIXMAN_REPEAT_REFLECT)
|
|
{
|
|
if ((int32_t)pos & 0x10000)
|
|
{
|
|
pixman_color_t *tmp_c;
|
|
int32_t tmp_x;
|
|
|
|
tmp_x = 0x10000 - right_x;
|
|
right_x = 0x10000 - left_x;
|
|
left_x = tmp_x;
|
|
|
|
tmp_c = right_c;
|
|
right_c = left_c;
|
|
left_c = tmp_c;
|
|
|
|
x = 0x10000 - x;
|
|
}
|
|
left_x += (pos - x);
|
|
right_x += (pos - x);
|
|
}
|
|
else if (walker->repeat == PIXMAN_REPEAT_NONE)
|
|
{
|
|
if (n == 0)
|
|
right_c = left_c;
|
|
else if (n == count)
|
|
left_c = right_c;
|
|
}
|
|
|
|
/* The alpha channel is scaled to be in the [0, 255] interval,
|
|
* and the red/green/blue channels are scaled to be in [0, 1].
|
|
* This ensures that after premultiplication all channels will
|
|
* be in the [0, 255] interval.
|
|
*/
|
|
la = (left_c->alpha * (1.0f/257.0f));
|
|
lr = (left_c->red * (1.0f/257.0f));
|
|
lg = (left_c->green * (1.0f/257.0f));
|
|
lb = (left_c->blue * (1.0f/257.0f));
|
|
|
|
ra = (right_c->alpha * (1.0f/257.0f));
|
|
rr = (right_c->red * (1.0f/257.0f));
|
|
rg = (right_c->green * (1.0f/257.0f));
|
|
rb = (right_c->blue * (1.0f/257.0f));
|
|
|
|
lx = left_x * (1.0f/65536.0f);
|
|
rx = right_x * (1.0f/65536.0f);
|
|
|
|
if (FLOAT_IS_ZERO (rx - lx) || left_x == INT32_MIN || right_x == INT32_MAX)
|
|
{
|
|
walker->a_s = walker->r_s = walker->g_s = walker->b_s = 0.0f;
|
|
walker->a_b = (la + ra) / 2.0f;
|
|
walker->r_b = (lr + rr) / 510.0f;
|
|
walker->g_b = (lg + rg) / 510.0f;
|
|
walker->b_b = (lb + rb) / 510.0f;
|
|
}
|
|
else
|
|
{
|
|
float w_rec = 1.0f / (rx - lx);
|
|
|
|
walker->a_b = (la * rx - ra * lx) * w_rec;
|
|
walker->r_b = (lr * rx - rr * lx) * w_rec * (1.0f/255.0f);
|
|
walker->g_b = (lg * rx - rg * lx) * w_rec * (1.0f/255.0f);
|
|
walker->b_b = (lb * rx - rb * lx) * w_rec * (1.0f/255.0f);
|
|
|
|
walker->a_s = (ra - la) * w_rec;
|
|
walker->r_s = (rr - lr) * w_rec * (1.0f/255.0f);
|
|
walker->g_s = (rg - lg) * w_rec * (1.0f/255.0f);
|
|
walker->b_s = (rb - lb) * w_rec * (1.0f/255.0f);
|
|
}
|
|
|
|
walker->left_x = left_x;
|
|
walker->right_x = right_x;
|
|
|
|
walker->need_reset = FALSE;
|
|
}
|
|
|
|
uint32_t
|
|
_pixman_gradient_walker_pixel (pixman_gradient_walker_t *walker,
|
|
pixman_fixed_48_16_t x)
|
|
{
|
|
float a, r, g, b;
|
|
uint8_t a8, r8, g8, b8;
|
|
uint32_t v;
|
|
float y;
|
|
|
|
if (walker->need_reset || x < walker->left_x || x >= walker->right_x)
|
|
gradient_walker_reset (walker, x);
|
|
|
|
y = x * (1.0f / 65536.0f);
|
|
|
|
a = walker->a_s * y + walker->a_b;
|
|
r = a * (walker->r_s * y + walker->r_b);
|
|
g = a * (walker->g_s * y + walker->g_b);
|
|
b = a * (walker->b_s * y + walker->b_b);
|
|
|
|
a8 = a + 0.5f;
|
|
r8 = r + 0.5f;
|
|
g8 = g + 0.5f;
|
|
b8 = b + 0.5f;
|
|
|
|
v = ((a8 << 24) & 0xff000000) |
|
|
((r8 << 16) & 0x00ff0000) |
|
|
((g8 << 8) & 0x0000ff00) |
|
|
((b8 >> 0) & 0x000000ff);
|
|
|
|
return v;
|
|
}
|