WebSVN – Kolibri OS – Diff – /programs/develop/libraries/pixman/pixman-radial-gradient.c

 		      pixman_gradient_walker_t *walker,
 		      pixman_repeat_t           repeat)
+{
     /*
      * In this function error propagation can lead to bad results:
-     *  - det can have an unbound error (if b*b-a*c is very small),
+     *  - discr can have an unbound error (if b*b-a*c is very small),
      *    potentially making it the opposite sign of what it should have been
      *    (thus clearing a pixel that would have been colored or vice-versa)
-     *    or propagating the error to sqrtdet;
+     *    or propagating the error to sqrtdiscr;
-     *    if det has the wrong sign or b is very small, this can lead to bad
+     *    if discr has the wrong sign or b is very small, this can lead to bad
      *    results
+     *
      *  - the algorithm used to compute the solutions of the quadratic
      *    equation is not numerically stable (but saves one division compared
      *    to the numerically stable one);
      *    this can be a problem if a*c is much smaller than b*b
+     *
      *  - the above problems are worse if a is small (as inva becomes bigger)
      */
-    double det;
+    double discr;
     if (a == 0)
+    {
 	    if (0 <= t && t <= pixman_fixed_1)
 		return _pixman_gradient_walker_pixel (walker, t);
+	}
 	else
+	{
-	    if (t * dr > mindr)
+	    if (t * dr >= mindr)
 		return _pixman_gradient_walker_pixel (walker, t);
+	}
 	return 0;
     }
-    det = fdot (b, a, 0, b, -c, 0);
+    discr = fdot (b, a, 0, b, -c, 0);
-    if (det >= 0)
+    if (discr >= 0)
     {
-	double sqrtdet, t0, t1;
+	double sqrtdiscr, t0, t1;
+	sqrtdiscr = sqrt (discr);
+	t0 = (b + sqrtdiscr) * inva;
+	t1 = (b - sqrtdiscr) * inva;
+	/*
+	 * The root that must be used is the biggest one that belongs
+	 * to the valid range ([0,1] for PIXMAN_REPEAT_NONE, any
+	 * solution that results in a positive radius otherwise).
+	 *
+	 * If a > 0, t0 is the biggest solution, so if it is valid, it
+	 * is the correct result.
 	sqrtdet = sqrt (det);
-	t0 = (b + sqrtdet) * inva;
+	 * If a < 0, only one of the solutions can be valid, so the
-	t1 = (b - sqrtdet) * inva;
+	 * order in which they are tested is not important.
 	 */
 	if (repeat == PIXMAN_REPEAT_NONE)
+	{
 	    if (0 <= t0 && t0 <= pixman_fixed_1)
 		return _pixman_gradient_walker_pixel (walker, t0);
 	    else if (0 <= t1 && t1 <= pixman_fixed_1)
 		return _pixman_gradient_walker_pixel (walker, t1);
+	}
 	else
+	{
-	    if (t0 * dr > mindr)
+	    if (t0 * dr >= mindr)
 		return _pixman_gradient_walker_pixel (walker, t0);
-	    else if (t1 * dr > mindr)
+	    else if (t1 * dr >= mindr)
 		return _pixman_gradient_walker_pixel (walker, t1);
 	}
     }
-    return 0;
-}
-static void
 radial_gradient_get_scanline_32 (pixman_image_t *image,
-                                 int             x,
+    return 0;
                                  int             y,
                                  int             width,
-                                 uint32_t *      buffer,
+static uint32_t *
      * Further limitations on the range of values for t are imposed when
      * the gradient is not repeated, namely t must belong to [0,1].
+     *
      * The graphical result is the same as drawing the valid (radius > 0)
      * circles with increasing t in [-inf, +inf] (or in [0,1] if the gradient
-     * is not repeated) using SOURCE operatior composition.
+     * is not repeated) using SOURCE operator composition.
+     *
      * It looks like a cone pointing towards the viewer if the ending circle
      * is smaller than the starting one, a cone pointing inside the page if
      * the starting circle is the smaller one and like a cylinder if they
      * have the same radius.
      * variables:
+     *
      *     cd = c₂ - c₁
      *     pd = p - c₁
      *     dr = r₂ - r₁
-     *     lenght(t·cd - pd) = r₁ + t·dr
+     *     length(t·cd - pd) = r₁ + t·dr
+     *
      * which actually means
+     *
      *     hypot(t·cdx - pdx, t·cdy - pdy) = r₁ + t·dr
+     *
+     *
      * A < 0 <=> one of the two circles completely contains the other one
      *   <=> for every p, the radiuses associated with the two t solutions
      *       have opposite sign
      */
+    pixman_image_t *image = iter->image;
+    int x = iter->x;
+    int y = iter->y;
+    int width = iter->width;
+    uint32_t *buffer = iter->buffer;
-    gradient_t *gradient = (gradient_t *)image;
-    source_image_t *source = (source_image_t *)image;
+    gradient_t *gradient = (gradient_t *)image;
     radial_gradient_t *radial = (radial_gradient_t *)image;
     uint32_t *end = buffer + width;
     pixman_gradient_walker_t walker;
     pixman_vector_t v, unit;
     /* 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;
-    _pixman_gradient_walker_init (&walker, gradient, source->common.repeat);
+    _pixman_gradient_walker_init (&walker, gradient, image->common.repeat);
-    if (source->common.transform)
+    if (image->common.transform)
     {
-	if (!pixman_transform_point_3d (source->common.transform, &v))
+	if (!pixman_transform_point_3d (image->common.transform, &v))
-	    return;
+	    return iter->buffer;
-	unit.vector[0] = source->common.transform->matrix[0][0];
+	unit.vector[0] = image->common.transform->matrix[0][0];
-	unit.vector[1] = source->common.transform->matrix[1][0];
+	unit.vector[1] = image->common.transform->matrix[1][0];
-	unit.vector[2] = source->common.transform->matrix[2][0];
+	unit.vector[2] = image->common.transform->matrix[2][0];
 		*buffer = radial_compute_color (radial->a, b, c,
 						radial->inva,
 						radial->delta.radius,
 						radial->mindr,
 						&walker,
-						source->common.repeat);
+						image->common.repeat);
+	    }
 	    b += db;
 	    c += dc;
 		    *buffer = radial_compute_color (radial->a, b, c,
 						    radial->inva,
 						    radial->delta.radius,
 						    radial->mindr,
 						    &walker,
-						    source->common.repeat);
+						    image->common.repeat);
+		}
 		else
+		{
 		    *buffer = 0;
+		}
 	    v.vector[0] += unit.vector[0];
 	    v.vector[1] += unit.vector[1];
 	    v.vector[2] += unit.vector[2];
+	}
+    }
+    iter->y++;
+    return iter->buffer;
+}
-static void
+static uint32_t *
-radial_gradient_property_changed (pixman_image_t *image)
+radial_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)
+{
+    uint32_t *buffer = radial_get_scanline_narrow (iter, NULL);
+    pixman_expand_to_float (
+	(argb_t *)buffer, buffer, PIXMAN_a8r8g8b8, iter->width);
+    return buffer;
+}
+void
+_pixman_radial_gradient_iter_init (pixman_image_t *image, pixman_iter_t *iter)
+{
-{
+    if (iter->iter_flags & ITER_NARROW)
+	iter->get_scanline = radial_get_scanline_narrow;
-    image->common.get_scanline_32 = radial_gradient_get_scanline_32;
+    else
-    image->common.get_scanline_64 = _pixman_image_get_scanline_generic_64;
+	iter->get_scanline = radial_get_scanline_wide;
+}
 PIXMAN_EXPORT pixman_image_t *
-pixman_image_create_radial_gradient (pixman_point_fixed_t *        inner,
+pixman_image_create_radial_gradient (const pixman_point_fixed_t *  inner,
-                                     pixman_point_fixed_t *        outer,
+                                     const pixman_point_fixed_t *  outer,
                                      pixman_fixed_t                inner_radius,
                                      pixman_fixed_t                outer_radius,
                                      const pixman_gradient_stop_t *stops,
     if (radial->a != 0)
 	radial->inva = 1. * pixman_fixed_1 / radial->a;
-    radial->mindr = -1. * pixman_fixed_1 * radial->c1.radius;
-    image->common.property_changed = radial_gradient_property_changed;
+    radial->mindr = -1. * pixman_fixed_1 * radial->c1.radius;
-    return image;

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/pixman/pixman-radial-gradient.c – Rev 1891 → 3931