mirror of
https://github.com/KolibriOS/kolibrios.git
synced 2024-12-15 11:22:34 +03:00
288 lines
7.3 KiB
C
288 lines
7.3 KiB
C
/* -*- Mode: c; c-basic-offset: 4; tab-width: 8; indent-tabs-mode: t; -*- */
|
|
/*
|
|
* Copyright © 2000 SuSE, Inc.
|
|
* Copyright © 2007 Red Hat, Inc.
|
|
* 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 <stdlib.h>
|
|
#include "pixman-private.h"
|
|
|
|
static pixman_bool_t
|
|
linear_gradient_is_horizontal (pixman_image_t *image,
|
|
int x,
|
|
int y,
|
|
int width,
|
|
int height)
|
|
{
|
|
linear_gradient_t *linear = (linear_gradient_t *)image;
|
|
pixman_vector_t v;
|
|
pixman_fixed_32_32_t l;
|
|
pixman_fixed_48_16_t dx, dy;
|
|
double inc;
|
|
|
|
if (image->common.transform)
|
|
{
|
|
/* projective transformation */
|
|
if (image->common.transform->matrix[2][0] != 0 ||
|
|
image->common.transform->matrix[2][1] != 0 ||
|
|
image->common.transform->matrix[2][2] == 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
v.vector[0] = image->common.transform->matrix[0][1];
|
|
v.vector[1] = image->common.transform->matrix[1][1];
|
|
v.vector[2] = image->common.transform->matrix[2][2];
|
|
}
|
|
else
|
|
{
|
|
v.vector[0] = 0;
|
|
v.vector[1] = pixman_fixed_1;
|
|
v.vector[2] = pixman_fixed_1;
|
|
}
|
|
|
|
dx = linear->p2.x - linear->p1.x;
|
|
dy = linear->p2.y - linear->p1.y;
|
|
|
|
l = dx * dx + dy * dy;
|
|
|
|
if (l == 0)
|
|
return FALSE;
|
|
|
|
/*
|
|
* compute how much the input of the gradient walked changes
|
|
* when moving vertically through the whole image
|
|
*/
|
|
inc = height * (double) pixman_fixed_1 * pixman_fixed_1 *
|
|
(dx * v.vector[0] + dy * v.vector[1]) /
|
|
(v.vector[2] * (double) l);
|
|
|
|
/* check that casting to integer would result in 0 */
|
|
if (-1 < inc && inc < 1)
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static uint32_t *
|
|
linear_get_scanline_narrow (pixman_iter_t *iter,
|
|
const uint32_t *mask)
|
|
{
|
|
pixman_image_t *image = iter->image;
|
|
int x = iter->x;
|
|
int y = iter->y;
|
|
int width = iter->width;
|
|
uint32_t * buffer = iter->buffer;
|
|
|
|
pixman_vector_t v, unit;
|
|
pixman_fixed_32_32_t l;
|
|
pixman_fixed_48_16_t dx, dy;
|
|
gradient_t *gradient = (gradient_t *)image;
|
|
linear_gradient_t *linear = (linear_gradient_t *)image;
|
|
uint32_t *end = buffer + width;
|
|
pixman_gradient_walker_t walker;
|
|
|
|
_pixman_gradient_walker_init (&walker, gradient, image->common.repeat);
|
|
|
|
/* reference point is the center of the pixel */
|
|
v.vector[0] = pixman_int_to_fixed (x) + pixman_fixed_1 / 2;
|
|
v.vector[1] = pixman_int_to_fixed (y) + pixman_fixed_1 / 2;
|
|
v.vector[2] = pixman_fixed_1;
|
|
|
|
if (image->common.transform)
|
|
{
|
|
if (!pixman_transform_point_3d (image->common.transform, &v))
|
|
return iter->buffer;
|
|
|
|
unit.vector[0] = image->common.transform->matrix[0][0];
|
|
unit.vector[1] = image->common.transform->matrix[1][0];
|
|
unit.vector[2] = image->common.transform->matrix[2][0];
|
|
}
|
|
else
|
|
{
|
|
unit.vector[0] = pixman_fixed_1;
|
|
unit.vector[1] = 0;
|
|
unit.vector[2] = 0;
|
|
}
|
|
|
|
dx = linear->p2.x - linear->p1.x;
|
|
dy = linear->p2.y - linear->p1.y;
|
|
|
|
l = dx * dx + dy * dy;
|
|
|
|
if (l == 0 || unit.vector[2] == 0)
|
|
{
|
|
/* affine transformation only */
|
|
pixman_fixed_32_32_t t, next_inc;
|
|
double inc;
|
|
|
|
if (l == 0 || v.vector[2] == 0)
|
|
{
|
|
t = 0;
|
|
inc = 0;
|
|
}
|
|
else
|
|
{
|
|
double invden, v2;
|
|
|
|
invden = pixman_fixed_1 * (double) pixman_fixed_1 /
|
|
(l * (double) v.vector[2]);
|
|
v2 = v.vector[2] * (1. / pixman_fixed_1);
|
|
t = ((dx * v.vector[0] + dy * v.vector[1]) -
|
|
(dx * linear->p1.x + dy * linear->p1.y) * v2) * invden;
|
|
inc = (dx * unit.vector[0] + dy * unit.vector[1]) * invden;
|
|
}
|
|
next_inc = 0;
|
|
|
|
if (((pixman_fixed_32_32_t )(inc * width)) == 0)
|
|
{
|
|
register uint32_t color;
|
|
|
|
color = _pixman_gradient_walker_pixel (&walker, t);
|
|
while (buffer < end)
|
|
*buffer++ = color;
|
|
}
|
|
else
|
|
{
|
|
int i;
|
|
|
|
i = 0;
|
|
while (buffer < end)
|
|
{
|
|
if (!mask || *mask++)
|
|
{
|
|
*buffer = _pixman_gradient_walker_pixel (&walker,
|
|
t + next_inc);
|
|
}
|
|
i++;
|
|
next_inc = inc * i;
|
|
buffer++;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* projective transformation */
|
|
double t;
|
|
|
|
t = 0;
|
|
|
|
while (buffer < end)
|
|
{
|
|
if (!mask || *mask++)
|
|
{
|
|
if (v.vector[2] != 0)
|
|
{
|
|
double invden, v2;
|
|
|
|
invden = pixman_fixed_1 * (double) pixman_fixed_1 /
|
|
(l * (double) v.vector[2]);
|
|
v2 = v.vector[2] * (1. / pixman_fixed_1);
|
|
t = ((dx * v.vector[0] + dy * v.vector[1]) -
|
|
(dx * linear->p1.x + dy * linear->p1.y) * v2) * invden;
|
|
}
|
|
|
|
*buffer = _pixman_gradient_walker_pixel (&walker, t);
|
|
}
|
|
|
|
++buffer;
|
|
|
|
v.vector[0] += unit.vector[0];
|
|
v.vector[1] += unit.vector[1];
|
|
v.vector[2] += unit.vector[2];
|
|
}
|
|
}
|
|
|
|
iter->y++;
|
|
|
|
return iter->buffer;
|
|
}
|
|
|
|
static uint32_t *
|
|
linear_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)
|
|
{
|
|
uint32_t *buffer = linear_get_scanline_narrow (iter, NULL);
|
|
|
|
pixman_expand_to_float (
|
|
(argb_t *)buffer, buffer, PIXMAN_a8r8g8b8, iter->width);
|
|
|
|
return buffer;
|
|
}
|
|
|
|
void
|
|
_pixman_linear_gradient_iter_init (pixman_image_t *image, pixman_iter_t *iter)
|
|
{
|
|
if (linear_gradient_is_horizontal (
|
|
iter->image, iter->x, iter->y, iter->width, iter->height))
|
|
{
|
|
if (iter->iter_flags & ITER_NARROW)
|
|
linear_get_scanline_narrow (iter, NULL);
|
|
else
|
|
linear_get_scanline_wide (iter, NULL);
|
|
|
|
iter->get_scanline = _pixman_iter_get_scanline_noop;
|
|
}
|
|
else
|
|
{
|
|
if (iter->iter_flags & ITER_NARROW)
|
|
iter->get_scanline = linear_get_scanline_narrow;
|
|
else
|
|
iter->get_scanline = linear_get_scanline_wide;
|
|
}
|
|
}
|
|
|
|
PIXMAN_EXPORT pixman_image_t *
|
|
pixman_image_create_linear_gradient (const pixman_point_fixed_t * p1,
|
|
const pixman_point_fixed_t * p2,
|
|
const pixman_gradient_stop_t *stops,
|
|
int n_stops)
|
|
{
|
|
pixman_image_t *image;
|
|
linear_gradient_t *linear;
|
|
|
|
image = _pixman_image_allocate ();
|
|
|
|
if (!image)
|
|
return NULL;
|
|
|
|
linear = &image->linear;
|
|
|
|
if (!_pixman_init_gradient (&linear->common, stops, n_stops))
|
|
{
|
|
free (image);
|
|
return NULL;
|
|
}
|
|
|
|
linear->p1 = *p1;
|
|
linear->p2 = *p2;
|
|
|
|
image->type = LINEAR;
|
|
|
|
return image;
|
|
}
|
|
|