summaryrefslogtreecommitdiffstats
path: root/app/paint/gimpmybrushsurface.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/paint/gimpmybrushsurface.c')
-rw-r--r--app/paint/gimpmybrushsurface.c560
1 files changed, 560 insertions, 0 deletions
diff --git a/app/paint/gimpmybrushsurface.c b/app/paint/gimpmybrushsurface.c
new file mode 100644
index 0000000..9b4283c
--- /dev/null
+++ b/app/paint/gimpmybrushsurface.c
@@ -0,0 +1,560 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include <gegl.h>
+
+#include <mypaint-surface.h>
+
+#include "paint-types.h"
+
+#include "libgimpmath/gimpmath.h"
+
+#include <cairo.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include "libgimpcolor/gimpcolor.h"
+
+#include "gimpmybrushoptions.h"
+#include "gimpmybrushsurface.h"
+
+
+struct _GimpMybrushSurface
+{
+ MyPaintSurface surface;
+ GeglBuffer *buffer;
+ GeglBuffer *paint_mask;
+ gint paint_mask_x;
+ gint paint_mask_y;
+ GeglRectangle dirty;
+ GimpComponentMask component_mask;
+ GimpMybrushOptions *options;
+};
+
+/* --- Taken from mypaint-tiled-surface.c --- */
+static inline float
+calculate_rr (int xp,
+ int yp,
+ float x,
+ float y,
+ float aspect_ratio,
+ float sn,
+ float cs,
+ float one_over_radius2)
+{
+ /* code duplication, see brush::count_dabs_to() */
+ const float yy = (yp + 0.5f - y);
+ const float xx = (xp + 0.5f - x);
+ const float yyr=(yy*cs-xx*sn)*aspect_ratio;
+ const float xxr=yy*sn+xx*cs;
+ const float rr = (yyr*yyr + xxr*xxr) * one_over_radius2;
+ /* rr is in range 0.0..1.0*sqrt(2) */
+ return rr;
+}
+
+static inline float
+calculate_r_sample (float x,
+ float y,
+ float aspect_ratio,
+ float sn,
+ float cs)
+{
+ const float yyr=(y*cs-x*sn)*aspect_ratio;
+ const float xxr=y*sn+x*cs;
+ const float r = (yyr*yyr + xxr*xxr);
+ return r;
+}
+
+static inline float
+sign_point_in_line (float px,
+ float py,
+ float vx,
+ float vy)
+{
+ return (px - vx) * (-vy) - (vx) * (py - vy);
+}
+
+static inline void
+closest_point_to_line (float lx,
+ float ly,
+ float px,
+ float py,
+ float *ox,
+ float *oy)
+{
+ const float l2 = lx*lx + ly*ly;
+ const float ltp_dot = px*lx + py*ly;
+ const float t = ltp_dot / l2;
+ *ox = lx * t;
+ *oy = ly * t;
+}
+
+
+/* This works by taking the visibility at the nearest point
+ * and dividing by 1.0 + delta.
+ *
+ * - nearest point: point where the dab has more influence
+ * - farthest point: point at a fixed distance away from
+ * the nearest point
+ * - delta: how much occluded is the farthest point relative
+ * to the nearest point
+ */
+static inline float
+calculate_rr_antialiased (int xp,
+ int yp,
+ float x,
+ float y,
+ float aspect_ratio,
+ float sn,
+ float cs,
+ float one_over_radius2,
+ float r_aa_start)
+{
+ /* calculate pixel position and borders in a way
+ * that the dab's center is always at zero */
+ float pixel_right = x - (float)xp;
+ float pixel_bottom = y - (float)yp;
+ float pixel_center_x = pixel_right - 0.5f;
+ float pixel_center_y = pixel_bottom - 0.5f;
+ float pixel_left = pixel_right - 1.0f;
+ float pixel_top = pixel_bottom - 1.0f;
+
+ float nearest_x, nearest_y; /* nearest to origin, but still inside pixel */
+ float farthest_x, farthest_y; /* farthest from origin, but still inside pixel */
+ float r_near, r_far, rr_near, rr_far;
+ float center_sign, rad_area_1, visibilityNear, delta, delta2;
+
+ /* Dab's center is inside pixel? */
+ if( pixel_left<0 && pixel_right>0 &&
+ pixel_top<0 && pixel_bottom>0 )
+ {
+ nearest_x = 0;
+ nearest_y = 0;
+ r_near = rr_near = 0;
+ }
+ else
+ {
+ closest_point_to_line( cs, sn, pixel_center_x, pixel_center_y, &nearest_x, &nearest_y );
+ nearest_x = CLAMP( nearest_x, pixel_left, pixel_right );
+ nearest_y = CLAMP( nearest_y, pixel_top, pixel_bottom );
+ /* XXX: precision of "nearest" values could be improved
+ * by intersecting the line that goes from nearest_x/Y to 0
+ * with the pixel's borders here, however the improvements
+ * would probably not justify the perdormance cost.
+ */
+ r_near = calculate_r_sample( nearest_x, nearest_y, aspect_ratio, sn, cs );
+ rr_near = r_near * one_over_radius2;
+ }
+
+ /* out of dab's reach? */
+ if( rr_near > 1.0f )
+ return rr_near;
+
+ /* check on which side of the dab's line is the pixel center */
+ center_sign = sign_point_in_line( pixel_center_x, pixel_center_y, cs, -sn );
+
+ /* radius of a circle with area=1
+ * A = pi * r * r
+ * r = sqrt(1/pi)
+ */
+ rad_area_1 = sqrtf( 1.0f / M_PI );
+
+ /* center is below dab */
+ if( center_sign < 0 )
+ {
+ farthest_x = nearest_x - sn*rad_area_1;
+ farthest_y = nearest_y + cs*rad_area_1;
+ }
+ /* above dab */
+ else
+ {
+ farthest_x = nearest_x + sn*rad_area_1;
+ farthest_y = nearest_y - cs*rad_area_1;
+ }
+
+ r_far = calculate_r_sample( farthest_x, farthest_y, aspect_ratio, sn, cs );
+ rr_far = r_far * one_over_radius2;
+
+ /* check if we can skip heavier AA */
+ if( r_far < r_aa_start )
+ return (rr_far+rr_near) * 0.5f;
+
+ /* calculate AA approximate */
+ visibilityNear = 1.0f - rr_near;
+ delta = rr_far - rr_near;
+ delta2 = 1.0f + delta;
+ visibilityNear /= delta2;
+
+ return 1.0f - visibilityNear;
+}
+/* -- end mypaint code */
+
+static inline float
+calculate_alpha_for_rr (float rr,
+ float hardness,
+ float slope1,
+ float slope2)
+{
+ if (rr > 1.0f)
+ return 0.0f;
+ else if (rr <= hardness)
+ return 1.0f + rr * slope1;
+ else
+ return rr * slope2 - slope2;
+}
+
+static GeglRectangle
+calculate_dab_roi (float x,
+ float y,
+ float radius)
+{
+ int x0 = floor (x - radius);
+ int x1 = ceil (x + radius);
+ int y0 = floor (y - radius);
+ int y1 = ceil (y + radius);
+
+ return *GEGL_RECTANGLE (x0, y0, x1 - x0, y1 - y0);
+}
+
+static void
+gimp_mypaint_surface_get_color (MyPaintSurface *base_surface,
+ float x,
+ float y,
+ float radius,
+ float *color_r,
+ float *color_g,
+ float *color_b,
+ float *color_a)
+{
+ GimpMybrushSurface *surface = (GimpMybrushSurface *)base_surface;
+ GeglRectangle dabRect;
+
+ if (radius < 1.0f)
+ radius = 1.0f;
+
+ dabRect = calculate_dab_roi (x, y, radius);
+
+ *color_r = 0.0f;
+ *color_g = 0.0f;
+ *color_b = 0.0f;
+ *color_a = 0.0f;
+
+ if (dabRect.width > 0 || dabRect.height > 0)
+ {
+ const float one_over_radius2 = 1.0f / (radius * radius);
+ float sum_weight = 0.0f;
+ float sum_r = 0.0f;
+ float sum_g = 0.0f;
+ float sum_b = 0.0f;
+ float sum_a = 0.0f;
+
+ /* Read in clamp mode to avoid transparency bleeding in at the edges */
+ GeglBufferIterator *iter = gegl_buffer_iterator_new (surface->buffer, &dabRect, 0,
+ babl_format ("R'aG'aB'aA float"),
+ GEGL_BUFFER_READ,
+ GEGL_ABYSS_CLAMP, 2);
+ if (surface->paint_mask)
+ {
+ GeglRectangle mask_roi = dabRect;
+ mask_roi.x -= surface->paint_mask_x;
+ mask_roi.y -= surface->paint_mask_y;
+ gegl_buffer_iterator_add (iter, surface->paint_mask, &mask_roi, 0,
+ babl_format ("Y float"),
+ GEGL_ACCESS_READ, GEGL_ABYSS_NONE);
+ }
+
+ while (gegl_buffer_iterator_next (iter))
+ {
+ float *pixel = (float *)iter->items[0].data;
+ float *mask;
+ int iy, ix;
+
+ if (surface->paint_mask)
+ mask = iter->items[1].data;
+ else
+ mask = NULL;
+
+ for (iy = iter->items[0].roi.y; iy < iter->items[0].roi.y + iter->items[0].roi.height; iy++)
+ {
+ float yy = (iy + 0.5f - y);
+ for (ix = iter->items[0].roi.x; ix < iter->items[0].roi.x + iter->items[0].roi.width; ix++)
+ {
+ /* pixel_weight == a standard dab with hardness = 0.5, aspect_ratio = 1.0, and angle = 0.0 */
+ float xx = (ix + 0.5f - x);
+ float rr = (yy * yy + xx * xx) * one_over_radius2;
+ float pixel_weight = 0.0f;
+ if (rr <= 1.0f)
+ pixel_weight = 1.0f - rr;
+ if (mask)
+ pixel_weight *= *mask;
+
+ sum_r += pixel_weight * pixel[RED];
+ sum_g += pixel_weight * pixel[GREEN];
+ sum_b += pixel_weight * pixel[BLUE];
+ sum_a += pixel_weight * pixel[ALPHA];
+ sum_weight += pixel_weight;
+
+ pixel += 4;
+ if (mask)
+ mask += 1;
+ }
+ }
+ }
+
+ if (sum_a > 0.0f && sum_weight > 0.0f)
+ {
+ sum_r /= sum_weight;
+ sum_g /= sum_weight;
+ sum_b /= sum_weight;
+ sum_a /= sum_weight;
+
+ sum_r /= sum_a;
+ sum_g /= sum_a;
+ sum_b /= sum_a;
+
+ /* FIXME: Clamping is wrong because GEGL allows alpha > 1, this should probably re-multipy things */
+ *color_r = CLAMP(sum_r, 0.0f, 1.0f);
+ *color_g = CLAMP(sum_g, 0.0f, 1.0f);
+ *color_b = CLAMP(sum_b, 0.0f, 1.0f);
+ *color_a = CLAMP(sum_a, 0.0f, 1.0f);
+ }
+ }
+
+}
+
+static int
+gimp_mypaint_surface_draw_dab (MyPaintSurface *base_surface,
+ float x,
+ float y,
+ float radius,
+ float color_r,
+ float color_g,
+ float color_b,
+ float opaque,
+ float hardness,
+ float color_a,
+ float aspect_ratio,
+ float angle,
+ float lock_alpha,
+ float colorize)
+{
+ GimpMybrushSurface *surface = (GimpMybrushSurface *)base_surface;
+ GeglBufferIterator *iter;
+ GeglRectangle dabRect;
+ GimpComponentMask component_mask = surface->component_mask;
+
+ const float one_over_radius2 = 1.0f / (radius * radius);
+ const double angle_rad = angle / 360 * 2 * M_PI;
+ const float cs = cos(angle_rad);
+ const float sn = sin(angle_rad);
+ float normal_mode;
+ float segment1_slope;
+ float segment2_slope;
+ float r_aa_start;
+
+ hardness = CLAMP (hardness, 0.0f, 1.0f);
+ segment1_slope = -(1.0f / hardness - 1.0f);
+ segment2_slope = -hardness / (1.0f - hardness);
+ aspect_ratio = MAX (1.0f, aspect_ratio);
+
+ r_aa_start = radius - 1.0f;
+ r_aa_start = MAX (r_aa_start, 0);
+ r_aa_start = (r_aa_start * r_aa_start) / aspect_ratio;
+
+ normal_mode = opaque * (1.0f - colorize);
+ colorize = opaque * colorize;
+
+ /* FIXME: This should use the real matrix values to trim aspect_ratio dabs */
+ dabRect = calculate_dab_roi (x, y, radius);
+ gegl_rectangle_intersect (&dabRect, &dabRect, gegl_buffer_get_extent (surface->buffer));
+
+ if (dabRect.width <= 0 || dabRect.height <= 0)
+ return 0;
+
+ gegl_rectangle_bounding_box (&surface->dirty, &surface->dirty, &dabRect);
+
+ iter = gegl_buffer_iterator_new (surface->buffer, &dabRect, 0,
+ babl_format ("R'G'B'A float"),
+ GEGL_BUFFER_READWRITE,
+ GEGL_ABYSS_NONE, 2);
+ if (surface->paint_mask)
+ {
+ GeglRectangle mask_roi = dabRect;
+ mask_roi.x -= surface->paint_mask_x;
+ mask_roi.y -= surface->paint_mask_y;
+ gegl_buffer_iterator_add (iter, surface->paint_mask, &mask_roi, 0,
+ babl_format ("Y float"),
+ GEGL_ACCESS_READ, GEGL_ABYSS_NONE);
+ }
+
+ while (gegl_buffer_iterator_next (iter))
+ {
+ float *pixel = (float *)iter->items[0].data;
+ float *mask;
+ int iy, ix;
+
+ if (surface->paint_mask)
+ mask = iter->items[1].data;
+ else
+ mask = NULL;
+
+ for (iy = iter->items[0].roi.y; iy < iter->items[0].roi.y + iter->items[0].roi.height; iy++)
+ {
+ for (ix = iter->items[0].roi.x; ix < iter->items[0].roi.x + iter->items[0].roi.width; ix++)
+ {
+ float rr, base_alpha, alpha, dst_alpha, r, g, b, a;
+ if (radius < 3.0f)
+ rr = calculate_rr_antialiased (ix, iy, x, y, aspect_ratio, sn, cs, one_over_radius2, r_aa_start);
+ else
+ rr = calculate_rr (ix, iy, x, y, aspect_ratio, sn, cs, one_over_radius2);
+ base_alpha = calculate_alpha_for_rr (rr, hardness, segment1_slope, segment2_slope);
+ alpha = base_alpha * normal_mode;
+ if (mask)
+ alpha *= *mask;
+ dst_alpha = pixel[ALPHA];
+ /* a = alpha * color_a + dst_alpha * (1.0f - alpha);
+ * which converts to: */
+ a = alpha * (color_a - dst_alpha) + dst_alpha;
+ r = pixel[RED];
+ g = pixel[GREEN];
+ b = pixel[BLUE];
+
+ if (a > 0.0f)
+ {
+ /* By definition the ratio between each color[] and pixel[] component in a non-pre-multipled blend always sums to 1.0f.
+ * Originally this would have been "(color[n] * alpha * color_a + pixel[n] * dst_alpha * (1.0f - alpha)) / a",
+ * instead we only calculate the cheaper term. */
+ float src_term = (alpha * color_a) / a;
+ float dst_term = 1.0f - src_term;
+ r = color_r * src_term + r * dst_term;
+ g = color_g * src_term + g * dst_term;
+ b = color_b * src_term + b * dst_term;
+ }
+
+ if (colorize > 0.0f && base_alpha > 0.0f)
+ {
+ alpha = base_alpha * colorize;
+ a = alpha + dst_alpha - alpha * dst_alpha;
+ if (a > 0.0f)
+ {
+ GimpHSL pixel_hsl, out_hsl;
+ GimpRGB pixel_rgb = {color_r, color_g, color_b};
+ GimpRGB out_rgb = {r, g, b};
+ float src_term = alpha / a;
+ float dst_term = 1.0f - src_term;
+
+ gimp_rgb_to_hsl (&pixel_rgb, &pixel_hsl);
+ gimp_rgb_to_hsl (&out_rgb, &out_hsl);
+
+ out_hsl.h = pixel_hsl.h;
+ out_hsl.s = pixel_hsl.s;
+ gimp_hsl_to_rgb (&out_hsl, &out_rgb);
+
+ r = (float)out_rgb.r * src_term + r * dst_term;
+ g = (float)out_rgb.g * src_term + g * dst_term;
+ b = (float)out_rgb.b * src_term + b * dst_term;
+ }
+ }
+
+ if (surface->options->no_erasing)
+ a = MAX (a, pixel[ALPHA]);
+
+ if (component_mask != GIMP_COMPONENT_MASK_ALL)
+ {
+ if (component_mask & GIMP_COMPONENT_MASK_RED)
+ pixel[RED] = r;
+ if (component_mask & GIMP_COMPONENT_MASK_GREEN)
+ pixel[GREEN] = g;
+ if (component_mask & GIMP_COMPONENT_MASK_BLUE)
+ pixel[BLUE] = b;
+ if (component_mask & GIMP_COMPONENT_MASK_ALPHA)
+ pixel[ALPHA] = a;
+ }
+ else
+ {
+ pixel[RED] = r;
+ pixel[GREEN] = g;
+ pixel[BLUE] = b;
+ pixel[ALPHA] = a;
+ }
+
+ pixel += 4;
+ if (mask)
+ mask += 1;
+ }
+ }
+ }
+
+ return 1;
+}
+
+static void
+gimp_mypaint_surface_begin_atomic (MyPaintSurface *base_surface)
+{
+
+}
+
+static void
+gimp_mypaint_surface_end_atomic (MyPaintSurface *base_surface,
+ MyPaintRectangle *roi)
+{
+ GimpMybrushSurface *surface = (GimpMybrushSurface *)base_surface;
+
+ roi->x = surface->dirty.x;
+ roi->y = surface->dirty.y;
+ roi->width = surface->dirty.width;
+ roi->height = surface->dirty.height;
+ surface->dirty = *GEGL_RECTANGLE (0, 0, 0, 0);
+}
+
+static void
+gimp_mypaint_surface_destroy (MyPaintSurface *base_surface)
+{
+ GimpMybrushSurface *surface = (GimpMybrushSurface *)base_surface;
+
+ g_clear_object (&surface->buffer);
+ g_clear_object (&surface->paint_mask);
+}
+
+GimpMybrushSurface *
+gimp_mypaint_surface_new (GeglBuffer *buffer,
+ GimpComponentMask component_mask,
+ GeglBuffer *paint_mask,
+ gint paint_mask_x,
+ gint paint_mask_y,
+ GimpMybrushOptions *options)
+{
+ GimpMybrushSurface *surface = g_malloc0 (sizeof (GimpMybrushSurface));
+
+ mypaint_surface_init ((MyPaintSurface *)surface);
+
+ surface->surface.get_color = gimp_mypaint_surface_get_color;
+ surface->surface.draw_dab = gimp_mypaint_surface_draw_dab;
+ surface->surface.begin_atomic = gimp_mypaint_surface_begin_atomic;
+ surface->surface.end_atomic = gimp_mypaint_surface_end_atomic;
+ surface->surface.destroy = gimp_mypaint_surface_destroy;
+ surface->component_mask = component_mask;
+ surface->options = options;
+ surface->buffer = g_object_ref (buffer);
+ if (paint_mask)
+ surface->paint_mask = g_object_ref (paint_mask);
+
+ surface->paint_mask_x = paint_mask_x;
+ surface->paint_mask_y = paint_mask_y;
+ surface->dirty = *GEGL_RECTANGLE (0, 0, 0, 0);
+
+ return surface;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-11 15:40:46 +0000