mirror of https://github.com/GNOME/gimp.git
1909 lines
58 KiB
C
1909 lines
58 KiB
C
/* The GIMP -- an 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 2 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, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <gtk/gtk.h>
|
|
|
|
#include "libgimpcolor/gimpcolor.h"
|
|
#include "libgimpmath/gimpmath.h"
|
|
#include "libgimpbase/gimpbase.h"
|
|
|
|
#include "paint-types.h"
|
|
|
|
#include "base/brush-scale.h"
|
|
#include "base/pixel-region.h"
|
|
#include "base/temp-buf.h"
|
|
#include "base/tile-manager.h"
|
|
#include "base/tile.h"
|
|
|
|
#include "paint-funcs/paint-funcs.h"
|
|
|
|
#include "core/gimpbrush.h"
|
|
#include "core/gimpcontext.h"
|
|
#include "core/gimpdrawable.h"
|
|
#include "core/gimpgradient.h"
|
|
#include "core/gimpimage.h"
|
|
#include "core/gimpimage-mask.h"
|
|
#include "core/gimpmarshal.h"
|
|
|
|
#include "gimppaintcore.h"
|
|
#include "gimppaintcore-kernels.h"
|
|
#include "gimppaintoptions.h"
|
|
|
|
#include "app_procs.h"
|
|
#include "gimprc.h"
|
|
#include "undo.h"
|
|
|
|
#include "libgimp/gimpintl.h"
|
|
|
|
|
|
#define EPSILON 0.00001
|
|
|
|
|
|
/* local function prototypes */
|
|
|
|
static void gimp_paint_core_class_init (GimpPaintCoreClass *klass);
|
|
static void gimp_paint_core_init (GimpPaintCore *core);
|
|
|
|
static void gimp_paint_core_finalize (GObject *object);
|
|
|
|
static void gimp_paint_core_calc_brush_size (GimpPaintCore *core,
|
|
MaskBuf *mask,
|
|
gdouble scale,
|
|
gint *width,
|
|
gint *height);
|
|
static MaskBuf * gimp_paint_core_subsample_mask (GimpPaintCore *core,
|
|
MaskBuf *mask,
|
|
gdouble x,
|
|
gdouble y);
|
|
static MaskBuf * gimp_paint_core_pressurize_mask (GimpPaintCore *core,
|
|
MaskBuf *brush_mask,
|
|
gdouble x,
|
|
gdouble y,
|
|
gdouble pressure);
|
|
static MaskBuf * gimp_paint_core_solidify_mask (GimpPaintCore *core,
|
|
MaskBuf *brush_mask);
|
|
static MaskBuf * gimp_paint_core_scale_mask (GimpPaintCore *core,
|
|
MaskBuf *brush_mask,
|
|
gdouble scale);
|
|
static MaskBuf * gimp_paint_core_scale_pixmap (GimpPaintCore *core,
|
|
MaskBuf *brush_mask,
|
|
gdouble scale);
|
|
|
|
static MaskBuf * gimp_paint_core_get_brush_mask (GimpPaintCore *core,
|
|
GimpBrushApplicationMode brush_hardness,
|
|
gdouble scale);
|
|
static void gimp_paint_core_paste (GimpPaintCore *core,
|
|
MaskBuf *brush_mask,
|
|
GimpDrawable *drawable,
|
|
gdouble brush_opacity,
|
|
gdouble image_opacity,
|
|
GimpLayerModeEffects paint_mode,
|
|
GimpPaintApplicationMode mode);
|
|
static void gimp_paint_core_replace (GimpPaintCore *core,
|
|
MaskBuf *brush_mask,
|
|
GimpDrawable *drawable,
|
|
gdouble brush_opacity,
|
|
gdouble image_opacity,
|
|
GimpPaintApplicationMode mode);
|
|
|
|
static void brush_to_canvas_tiles (GimpPaintCore *core,
|
|
MaskBuf *brush_mask,
|
|
gdouble brush_opacity);
|
|
static void brush_to_canvas_buf (GimpPaintCore *core,
|
|
MaskBuf *brush_mask,
|
|
gdouble brush_opacity);
|
|
static void canvas_tiles_to_canvas_buf (GimpPaintCore *core);
|
|
|
|
static void set_undo_tiles (GimpPaintCore *core,
|
|
GimpDrawable *drawable,
|
|
gint x,
|
|
gint y,
|
|
gint w,
|
|
gint h);
|
|
static void set_canvas_tiles (GimpPaintCore *core,
|
|
gint x,
|
|
gint y,
|
|
gint w,
|
|
gint h);
|
|
static void gimp_paint_core_invalidate_cache (GimpBrush *brush,
|
|
GimpPaintCore *core);
|
|
|
|
|
|
/* brush pipe utility functions */
|
|
static void paint_line_pixmap_mask (GimpImage *dest,
|
|
GimpDrawable *drawable,
|
|
TempBuf *pixmap_mask,
|
|
TempBuf *brush_mask,
|
|
guchar *d,
|
|
gint x,
|
|
gint y,
|
|
gint bytes,
|
|
gint width,
|
|
GimpBrushApplicationMode mode);
|
|
|
|
|
|
static GimpObjectClass *parent_class = NULL;
|
|
|
|
static gint global_core_ID = 0;
|
|
|
|
|
|
GType
|
|
gimp_paint_core_get_type (void)
|
|
{
|
|
static GType core_type = 0;
|
|
|
|
if (! core_type)
|
|
{
|
|
static const GTypeInfo core_info =
|
|
{
|
|
sizeof (GimpPaintCoreClass),
|
|
(GBaseInitFunc) NULL,
|
|
(GBaseFinalizeFunc) NULL,
|
|
(GClassInitFunc) gimp_paint_core_class_init,
|
|
NULL, /* class_finalize */
|
|
NULL, /* class_data */
|
|
sizeof (GimpPaintCore),
|
|
0, /* n_preallocs */
|
|
(GInstanceInitFunc) gimp_paint_core_init,
|
|
};
|
|
|
|
core_type = g_type_register_static (GIMP_TYPE_OBJECT,
|
|
"GimpPaintCore",
|
|
&core_info, 0);
|
|
}
|
|
|
|
return core_type;
|
|
}
|
|
|
|
static void
|
|
gimp_paint_core_class_init (GimpPaintCoreClass *klass)
|
|
{
|
|
GObjectClass *object_class;
|
|
|
|
object_class = G_OBJECT_CLASS (klass);
|
|
|
|
parent_class = g_type_class_peek_parent (klass);
|
|
|
|
object_class->finalize = gimp_paint_core_finalize;
|
|
|
|
klass->paint = NULL;
|
|
}
|
|
|
|
static void
|
|
gimp_paint_core_init (GimpPaintCore *core)
|
|
{
|
|
gint i, j;
|
|
|
|
core->ID = global_core_ID++;
|
|
|
|
core->distance = 0.0;
|
|
core->spacing = 0.0;
|
|
core->x1 = 0;
|
|
core->y1 = 0;
|
|
core->x2 = 0;
|
|
core->y2 = 0;
|
|
|
|
core->brush = NULL;
|
|
|
|
core->flags = 0;
|
|
core->use_pressure = FALSE;
|
|
|
|
core->undo_tiles = NULL;
|
|
core->canvas_tiles = NULL;
|
|
|
|
core->orig_buf = NULL;
|
|
core->canvas_buf = NULL;
|
|
|
|
core->pressure_brush = NULL;
|
|
|
|
core->solid_brush = NULL;
|
|
core->last_solid_brush = NULL;
|
|
|
|
core->scale_brush = NULL;
|
|
core->last_scale_brush = NULL;
|
|
core->last_scale_width = 0;
|
|
core->last_scale_height = 0;
|
|
|
|
core->scale_pixmap = NULL;
|
|
core->last_scale_pixmap = NULL;
|
|
core->last_scale_pixmap_width = 0;
|
|
core->last_scale_pixmap_height = 0;
|
|
|
|
g_assert (PAINT_CORE_SUBSAMPLE == KERNEL_SUBSAMPLE);
|
|
|
|
for (i = 0; i < KERNEL_SUBSAMPLE + 1; i++)
|
|
for (j = 0; j < KERNEL_SUBSAMPLE + 1; j++)
|
|
core->kernel_brushes[i][j] = NULL;
|
|
|
|
core->last_brush_mask = NULL;
|
|
core->cache_invalid = FALSE;
|
|
|
|
core->grr_brush = NULL;
|
|
}
|
|
|
|
static void
|
|
gimp_paint_core_finalize (GObject *object)
|
|
{
|
|
GimpPaintCore *core;
|
|
gint i, j;
|
|
|
|
core = GIMP_PAINT_CORE (object);
|
|
|
|
gimp_paint_core_cleanup (core);
|
|
|
|
if (core->pressure_brush)
|
|
{
|
|
temp_buf_free (core->pressure_brush);
|
|
core->pressure_brush = NULL;
|
|
}
|
|
|
|
if (core->solid_brush)
|
|
{
|
|
temp_buf_free (core->solid_brush);
|
|
core->solid_brush = NULL;
|
|
}
|
|
|
|
if (core->scale_brush)
|
|
{
|
|
temp_buf_free (core->scale_brush);
|
|
core->scale_brush = NULL;
|
|
}
|
|
|
|
if (core->scale_pixmap)
|
|
{
|
|
temp_buf_free (core->scale_pixmap);
|
|
core->scale_pixmap = NULL;
|
|
}
|
|
|
|
for (i = 0; i < KERNEL_SUBSAMPLE + 1; i++)
|
|
for (j = 0; j < KERNEL_SUBSAMPLE + 1; j++)
|
|
if (core->kernel_brushes[i][j])
|
|
{
|
|
temp_buf_free (core->kernel_brushes[i][j]);
|
|
core->kernel_brushes[i][j] = NULL;
|
|
}
|
|
|
|
if (core->grr_brush)
|
|
{
|
|
g_signal_handlers_disconnect_by_func (G_OBJECT (core->grr_brush),
|
|
gimp_paint_core_invalidate_cache,
|
|
core);
|
|
g_object_unref (G_OBJECT (core->grr_brush));
|
|
core->grr_brush = NULL;
|
|
}
|
|
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
|
}
|
|
|
|
void
|
|
gimp_paint_core_paint (GimpPaintCore *core,
|
|
GimpDrawable *drawable,
|
|
GimpPaintOptions *paint_options,
|
|
GimpPaintCoreState paint_state)
|
|
{
|
|
g_return_if_fail (GIMP_IS_PAINT_CORE (core));
|
|
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
|
|
g_return_if_fail (paint_options != NULL);
|
|
|
|
if (paint_state == MOTION_PAINT)
|
|
{
|
|
/* If we current point == last point, check if the brush
|
|
* wants to be painted in that case. (Direction dependent
|
|
* pixmap brush pipes don't, as they don't know which
|
|
* pixmap to select.)
|
|
*/
|
|
if (core->last_coords.x == core->cur_coords.x &&
|
|
core->last_coords.y == core->cur_coords.y &&
|
|
! gimp_brush_want_null_motion (core->brush,
|
|
&core->last_coords,
|
|
&core->cur_coords))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (core->flags & CORE_HANDLES_CHANGING_BRUSH)
|
|
{
|
|
core->brush = gimp_brush_select_brush (core->brush,
|
|
&core->last_coords,
|
|
&core->cur_coords);
|
|
}
|
|
|
|
/* Save coordinates for gimp_paint_core_interpolate() */
|
|
core->last_paint.x = core->cur_coords.x;
|
|
core->last_paint.y = core->cur_coords.y;
|
|
}
|
|
|
|
GIMP_PAINT_CORE_GET_CLASS (core)->paint (core,
|
|
drawable,
|
|
paint_options,
|
|
paint_state);
|
|
}
|
|
|
|
gboolean
|
|
gimp_paint_core_start (GimpPaintCore *core,
|
|
GimpDrawable *drawable,
|
|
GimpPaintOptions *paint_options,
|
|
GimpCoords *coords)
|
|
{
|
|
GimpImage *gimage;
|
|
|
|
g_return_val_if_fail (GIMP_IS_PAINT_CORE (core), FALSE);
|
|
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
|
|
g_return_val_if_fail (paint_options != NULL, FALSE);
|
|
g_return_val_if_fail (coords != NULL, FALSE);
|
|
|
|
gimage = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
|
|
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
|
|
|
|
core->cur_coords = *coords;
|
|
|
|
/* Each buffer is the same size as
|
|
* the maximum bounds of the active brush...
|
|
*/
|
|
|
|
if (core->grr_brush &&
|
|
core->grr_brush != gimp_context_get_brush (paint_options->context))
|
|
{
|
|
g_signal_handlers_disconnect_by_func (G_OBJECT (core->grr_brush),
|
|
gimp_paint_core_invalidate_cache,
|
|
core);
|
|
g_object_unref (G_OBJECT (core->grr_brush));
|
|
}
|
|
|
|
core->grr_brush = gimp_context_get_brush (paint_options->context);
|
|
|
|
if (! core->grr_brush)
|
|
{
|
|
g_message (_("No brushes available for use with this tool."));
|
|
return FALSE;
|
|
}
|
|
|
|
g_object_ref (G_OBJECT (core->grr_brush));
|
|
g_signal_connect (G_OBJECT (core->grr_brush), "invalidate_preview",
|
|
G_CALLBACK (gimp_paint_core_invalidate_cache),
|
|
core);
|
|
|
|
core->spacing = (gdouble) gimp_brush_get_spacing (core->grr_brush) / 100.0;
|
|
|
|
core->brush = core->grr_brush;
|
|
|
|
/* Allocate the undo structure */
|
|
if (core->undo_tiles)
|
|
tile_manager_destroy (core->undo_tiles);
|
|
|
|
core->undo_tiles = tile_manager_new (gimp_drawable_width (drawable),
|
|
gimp_drawable_height (drawable),
|
|
gimp_drawable_bytes (drawable));
|
|
|
|
/* Allocate the canvas blocks structure */
|
|
if (core->canvas_tiles)
|
|
tile_manager_destroy (core->canvas_tiles);
|
|
|
|
core->canvas_tiles = tile_manager_new (gimp_drawable_width (drawable),
|
|
gimp_drawable_height (drawable),
|
|
1);
|
|
|
|
/* Get the initial undo extents */
|
|
|
|
core->x1 = core->x2 = core->cur_coords.x;
|
|
core->y1 = core->y2 = core->cur_coords.y;
|
|
core->distance = 0.0;
|
|
core->pixel_dist = 0.0;
|
|
|
|
core->last_paint.x = -1e6;
|
|
core->last_paint.y = -1e6;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
gimp_paint_core_finish (GimpPaintCore *core,
|
|
GimpDrawable *drawable)
|
|
{
|
|
GimpImage *gimage;
|
|
|
|
g_return_if_fail (GIMP_IS_PAINT_CORE (core));
|
|
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
|
|
|
|
gimage = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
|
|
g_return_if_fail (GIMP_IS_IMAGE (gimage));
|
|
|
|
/* Determine if any part of the image has been altered--
|
|
* if nothing has, then just return...
|
|
*/
|
|
|
|
if ((core->x2 == core->x1) ||
|
|
(core->y2 == core->y1))
|
|
return;
|
|
|
|
undo_push_group_start (gimage, PAINT_UNDO_GROUP);
|
|
|
|
undo_push_paint (gimage,
|
|
core->ID,
|
|
G_TYPE_FROM_INSTANCE (core),
|
|
&core->start_coords);
|
|
|
|
gimp_drawable_push_undo (drawable,
|
|
core->x1, core->y1,
|
|
core->x2, core->y2,
|
|
core->undo_tiles,
|
|
TRUE);
|
|
core->undo_tiles = NULL;
|
|
|
|
undo_push_group_end (gimage);
|
|
|
|
/* invalidate the drawable--have to do it here, because
|
|
* it is not done during the actual painting.
|
|
*/
|
|
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (drawable));
|
|
}
|
|
|
|
void
|
|
gimp_paint_core_cleanup (GimpPaintCore *core)
|
|
{
|
|
g_return_if_fail (GIMP_IS_PAINT_CORE (core));
|
|
|
|
if (core->undo_tiles)
|
|
{
|
|
tile_manager_destroy (core->undo_tiles);
|
|
core->undo_tiles = NULL;
|
|
}
|
|
|
|
if (core->canvas_tiles)
|
|
{
|
|
tile_manager_destroy (core->canvas_tiles);
|
|
core->canvas_tiles = NULL;
|
|
}
|
|
|
|
if (core->orig_buf)
|
|
{
|
|
temp_buf_free (core->orig_buf);
|
|
core->orig_buf = NULL;
|
|
}
|
|
|
|
if (core->canvas_buf)
|
|
{
|
|
temp_buf_free (core->canvas_buf);
|
|
core->canvas_buf = NULL;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gimp_paint_core_constrain:
|
|
* @core: the #GimpPaintCore.
|
|
*
|
|
* Restricts the (core->last_coords, core->curr_coords) vector to 15
|
|
* degree steps, possibly changing core->curr_coords
|
|
**/
|
|
void
|
|
gimp_paint_core_constrain (GimpPaintCore *core)
|
|
{
|
|
static const gint tangens2[6] = { 34, 106, 196, 334, 618, 1944 };
|
|
static const gint cosinus[7] = { 256, 247, 222, 181, 128, 66, 0 };
|
|
|
|
gint dx, dy, i, radius, frac;
|
|
|
|
g_return_if_fail (GIMP_IS_PAINT_CORE (core));
|
|
|
|
dx = core->cur_coords.x - core->last_coords.x;
|
|
dy = core->cur_coords.y - core->last_coords.y;
|
|
|
|
if (dy)
|
|
{
|
|
radius = sqrt (SQR (dx) + SQR (dy));
|
|
frac = abs ((dx << 8) / dy);
|
|
|
|
for (i = 0; i < 6; i++)
|
|
{
|
|
if (frac < tangens2[i])
|
|
break;
|
|
}
|
|
|
|
dx = (dx > 0 ?
|
|
(cosinus[6-i] * radius) >> 8 :
|
|
- ((cosinus[6-i] * radius) >> 8));
|
|
|
|
dy = (dy > 0 ?
|
|
(cosinus[i] * radius) >> 8 :
|
|
- ((cosinus[i] * radius) >> 8));
|
|
}
|
|
|
|
core->cur_coords.x = core->last_coords.x + dx;
|
|
core->cur_coords.y = core->last_coords.y + dy;
|
|
}
|
|
|
|
/**
|
|
* gimp_avoid_exact_integer
|
|
* @x: points to a gdouble
|
|
*
|
|
* Adjusts *x such that it is not too close to an integer. This is used
|
|
* for decision algorithms that would be vulnerable to rounding glitches
|
|
* if exact integers were input.
|
|
*
|
|
* Side effects: Changes the value of *x
|
|
**/
|
|
static void
|
|
gimp_avoid_exact_integer (gdouble *x)
|
|
{
|
|
gdouble integral = floor (*x);
|
|
gdouble fractional = *x - integral;
|
|
|
|
if (fractional < EPSILON)
|
|
*x = integral + EPSILON;
|
|
else if (fractional > (1-EPSILON))
|
|
*x = integral + (1-EPSILON);
|
|
}
|
|
|
|
void
|
|
gimp_paint_core_interpolate (GimpPaintCore *core,
|
|
GimpDrawable *drawable,
|
|
GimpPaintOptions *paint_options)
|
|
{
|
|
GimpCoords delta;
|
|
gint n, num_points;
|
|
gdouble t0, dt, tn;
|
|
gdouble st_factor, st_offset;
|
|
gdouble initial;
|
|
gdouble dist;
|
|
gdouble total;
|
|
gdouble pixel_dist;
|
|
gdouble pixel_initial;
|
|
gdouble xd, yd;
|
|
gdouble mag;
|
|
|
|
g_return_if_fail (GIMP_IS_PAINT_CORE (core));
|
|
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
|
|
g_return_if_fail (paint_options != NULL);
|
|
|
|
gimp_avoid_exact_integer (&core->last_coords.x);
|
|
gimp_avoid_exact_integer (&core->last_coords.y);
|
|
gimp_avoid_exact_integer (&core->cur_coords.x);
|
|
gimp_avoid_exact_integer (&core->cur_coords.y);
|
|
|
|
delta.x = core->cur_coords.x - core->last_coords.x;
|
|
delta.y = core->cur_coords.y - core->last_coords.y;
|
|
delta.pressure = core->cur_coords.pressure - core->last_coords.pressure;
|
|
delta.xtilt = core->cur_coords.xtilt - core->last_coords.xtilt;
|
|
delta.ytilt = core->cur_coords.ytilt - core->last_coords.ytilt;
|
|
delta.wheel = core->cur_coords.wheel - core->last_coords.wheel;
|
|
|
|
/* return if there has been no motion */
|
|
if (! delta.x &&
|
|
! delta.y &&
|
|
! delta.pressure &&
|
|
! delta.xtilt &&
|
|
! delta.ytilt &&
|
|
! delta.wheel)
|
|
return;
|
|
|
|
/* calculate the distance traveled in the coordinate space of the brush */
|
|
mag = gimp_vector2_length (&(core->brush->x_axis));
|
|
xd = gimp_vector2_inner_product ((GimpVector2 *) &delta,
|
|
&(core->brush->x_axis)) / (mag * mag);
|
|
|
|
mag = gimp_vector2_length (&(core->brush->y_axis));
|
|
yd = gimp_vector2_inner_product ((GimpVector2 *) &delta,
|
|
&(core->brush->y_axis)) / (mag * mag);
|
|
|
|
dist = 0.5 * sqrt (xd * xd + yd * yd);
|
|
total = dist + core->distance;
|
|
initial = core->distance;
|
|
|
|
pixel_dist = gimp_vector2_length ((GimpVector2 *) &delta);
|
|
pixel_initial = core->pixel_dist;
|
|
|
|
/* FIXME: need to adapt the spacing to the size */
|
|
/* lastscale = MIN (gimp_paint_tool->lastpressure, 1/256); */
|
|
/* curscale = MIN (gimp_paint_tool->curpressure, 1/256); */
|
|
/* spacing = gimp_paint_tool->spacing * sqrt (0.5 * (lastscale + curscale)); */
|
|
|
|
/* Compute spacing parameters such that a brush position will be
|
|
* made each time the line crosses the *center* of a pixel row or
|
|
* column, according to whether the line is mostly horizontal or
|
|
* mostly vertical. The term "stripe" will mean "column" if the
|
|
* line is horizontalish; "row" if the line is verticalish.
|
|
*
|
|
* We start by deriving coefficients for a new parameter 's':
|
|
* s = t * st_factor + st_offset
|
|
* such that the "nice" brush positions are the ones with *integer*
|
|
* s values. (Actually the value of s will be 1/2 less than the nice
|
|
* brush position's x or y coordinate - note that st_factor may
|
|
* be negative!)
|
|
*/
|
|
|
|
if (delta.x*delta.x > delta.y*delta.y)
|
|
{
|
|
st_factor = delta.x;
|
|
st_offset = core->last_coords.x - 0.5;
|
|
}
|
|
else
|
|
{
|
|
st_factor = delta.y;
|
|
st_offset = core->last_coords.y - 0.5;
|
|
}
|
|
|
|
if (fabs (st_factor) > dist / core->spacing)
|
|
{
|
|
/* The stripe principle leads to brush positions that are spaced
|
|
* *closer* than the official brush spacing. Use the official
|
|
* spacing instead. This is the common case when the brush spacing
|
|
* is large.
|
|
* The net effect is then to put a lower bound on the spacing, but
|
|
* one that varies with the slope of the line. This is suppose to
|
|
* make thin lines (say, with a 1x1 brush) prettier while leaving
|
|
* lines with larger brush spacing as they used to look in 1.2.x.
|
|
*/
|
|
dt = core->spacing / dist;
|
|
n = (gint) (initial / core->spacing + 1.0 + EPSILON);
|
|
t0 = (n * core->spacing - initial) / dist;
|
|
num_points = 1 + (gint) floor ((1 + EPSILON - t0) / dt);
|
|
}
|
|
else if (fabs (st_factor) < EPSILON)
|
|
{
|
|
/* Hm, we've hardly moved at all. Don't draw anything, but reset the
|
|
* old coordinates and hope we've gone longer the next time.
|
|
*/
|
|
core->cur_coords.x = core->last_coords.x;
|
|
core->cur_coords.y = core->last_coords.y;
|
|
/* ... but go along with the current pressure, tilt and wheel */
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
gint direction = st_factor > 0 ? 1 : -1;
|
|
gint x, y;
|
|
gint s0, sn;
|
|
|
|
/* Choose the first and last stripe to paint.
|
|
* FIRST PRIORITY is to avoid gaps painting with a 1x1 aliasing
|
|
* brush when a horizontalish line segment follows a verticalish
|
|
* one or vice versa - no matter what the angle between the two
|
|
* lines is. This will also limit the local thinning that a 1x1
|
|
* subsampled brush may suffer in the same situation.
|
|
* SECOND PRIORITY is to avoid making free-hand drawings
|
|
* unpleasantly fat by plotting redundant points.
|
|
* These are achieved by the following rules, but it is a little
|
|
* tricky to see just why. Do not change this algorithm unless you
|
|
* are sure you know what you're doing!
|
|
*/
|
|
|
|
/* Basic case: round the beginning and ending point to nearest
|
|
* stripe center.
|
|
*/
|
|
s0 = (gint) floor (st_offset + 0.5);
|
|
sn = (gint) floor (st_offset + st_factor + 0.5);
|
|
|
|
t0 = (s0 - st_offset) / st_factor;
|
|
tn = (sn - st_offset) / st_factor;
|
|
|
|
x = (gint) floor (core->last_coords.x + t0 * delta.x);
|
|
y = (gint) floor (core->last_coords.y + t0 * delta.y);
|
|
if (t0 < 0.0 && !( x == (gint) floor (core->last_coords.x) &&
|
|
y == (gint) floor (core->last_coords.y) ))
|
|
{
|
|
/* Exception A: If the first stripe's brush position is
|
|
* EXTRApolated into a different pixel square than the
|
|
* ideal starting point, dont't plot it.
|
|
*/
|
|
s0 += direction;
|
|
}
|
|
else if (x == (gint) floor (core->last_paint.x) &&
|
|
y == (gint) floor (core->last_paint.y))
|
|
{
|
|
/* Exception B: If first stripe's brush position is within the
|
|
* same pixel square as the last plot of the previous line,
|
|
* don't plot it either.
|
|
*/
|
|
s0 += direction;
|
|
}
|
|
|
|
x = (gint) floor (core->last_coords.x + tn * delta.x);
|
|
y = (gint) floor (core->last_coords.y + tn * delta.y);
|
|
if (tn > 1.0 && !( x == (gint) floor( core->cur_coords.x ) &&
|
|
y == (gint) floor( core->cur_coords.y ) ))
|
|
{
|
|
/* Exception C: If the last stripe's brush position is
|
|
* EXTRApolated into a different pixel square than the
|
|
* ideal ending point, don't plot it.
|
|
*/
|
|
sn -= direction;
|
|
}
|
|
|
|
t0 = (s0 - st_offset) / st_factor;
|
|
tn = (sn - st_offset) / st_factor;
|
|
dt = direction * 1.0 / st_factor;
|
|
num_points = 1 + direction * (sn - s0);
|
|
|
|
if (num_points >= 1)
|
|
{
|
|
/* Hack the reported total distance such that it looks to the
|
|
* next line as if the the last pixel plotted were at an integer
|
|
* multiple of the brush spacing. This helps prevent artifacts
|
|
* for connected lines when the brush spacing is such that some
|
|
* slopes will use the stripe regime and other slopes will use
|
|
* the nominal brush spacing.
|
|
*/
|
|
|
|
if (tn < 1)
|
|
total = initial + tn * dist;
|
|
|
|
total = core->spacing * (gint) (total / core->spacing + 0.5);
|
|
total += (1.0 - tn) * dist;
|
|
}
|
|
}
|
|
|
|
for (n = 0; n < num_points; n++)
|
|
{
|
|
GimpBrush *current_brush;
|
|
gdouble t = t0 + n*dt;
|
|
|
|
core->cur_coords.x = core->last_coords.x + t * delta.x;
|
|
core->cur_coords.y = core->last_coords.y + t * delta.y;
|
|
core->cur_coords.pressure = core->last_coords.pressure + t * delta.pressure;
|
|
core->cur_coords.xtilt = core->last_coords.xtilt + t * delta.xtilt;
|
|
core->cur_coords.ytilt = core->last_coords.ytilt + t * delta.ytilt;
|
|
core->cur_coords.wheel = core->last_coords.wheel + t * delta.wheel;
|
|
|
|
core->distance = initial + t * dist;
|
|
core->pixel_dist = pixel_initial + t * pixel_dist;
|
|
|
|
/* save the current brush */
|
|
current_brush = core->brush;
|
|
|
|
gimp_paint_core_paint (core, drawable, paint_options, MOTION_PAINT);
|
|
|
|
/* restore the current brush pointer */
|
|
core->brush = current_brush;
|
|
}
|
|
|
|
core->cur_coords.x = core->last_coords.x + delta.x;
|
|
core->cur_coords.y = core->last_coords.y + delta.y;
|
|
core->cur_coords.pressure = core->last_coords.pressure + delta.pressure;
|
|
core->cur_coords.xtilt = core->last_coords.xtilt + delta.xtilt;
|
|
core->cur_coords.ytilt = core->last_coords.ytilt + delta.ytilt;
|
|
core->cur_coords.wheel = core->last_coords.wheel + delta.wheel;
|
|
|
|
core->distance = total;
|
|
core->pixel_dist = pixel_initial + pixel_dist;
|
|
}
|
|
|
|
|
|
/* protected functions */
|
|
|
|
void
|
|
gimp_paint_core_get_color_from_gradient (GimpPaintCore *core,
|
|
GimpGradient *gradient,
|
|
gdouble gradient_length,
|
|
GimpRGB *color,
|
|
GimpGradientPaintMode mode)
|
|
{
|
|
gdouble pos;
|
|
|
|
pos = (gdouble) core->pixel_dist / gradient_length;
|
|
|
|
/* for the once modes, set pos close to 1.0 after the first chunk */
|
|
if ((mode == GIMP_GRADIENT_ONCE_FORWARD ||
|
|
mode == GIMP_GRADIENT_ONCE_BACKWARD) && pos >= 1.0)
|
|
pos = 0.9999999;
|
|
|
|
if ((((gint) pos & 1) && mode != GIMP_GRADIENT_LOOP_SAWTOOTH) ||
|
|
mode == GIMP_GRADIENT_ONCE_BACKWARD)
|
|
pos = 1.0 - (pos - (gint) pos);
|
|
else
|
|
pos = pos - (gint) pos;
|
|
|
|
gimp_gradient_get_color_at (gradient, pos, color);
|
|
}
|
|
|
|
TempBuf *
|
|
gimp_paint_core_get_paint_area (GimpPaintCore *core,
|
|
GimpDrawable *drawable,
|
|
gdouble scale)
|
|
{
|
|
gint x, y;
|
|
gint x1, y1, x2, y2;
|
|
gint bytes;
|
|
gint dwidth, dheight;
|
|
gint bwidth, bheight;
|
|
|
|
bytes = (gimp_drawable_has_alpha (drawable) ?
|
|
gimp_drawable_bytes (drawable) : gimp_drawable_bytes (drawable) + 1);
|
|
|
|
gimp_paint_core_calc_brush_size (core,
|
|
core->brush->mask,
|
|
scale,
|
|
&bwidth, &bheight);
|
|
|
|
/* adjust the x and y coordinates to the upper left corner of the brush */
|
|
x = (gint) floor (core->cur_coords.x) - (bwidth >> 1);
|
|
y = (gint) floor (core->cur_coords.y) - (bheight >> 1);
|
|
|
|
dwidth = gimp_drawable_width (drawable);
|
|
dheight = gimp_drawable_height (drawable);
|
|
|
|
x1 = CLAMP (x - 1, 0, dwidth);
|
|
y1 = CLAMP (y - 1, 0, dheight);
|
|
x2 = CLAMP (x + bwidth + 1, 0, dwidth);
|
|
y2 = CLAMP (y + bheight + 1, 0, dheight);
|
|
|
|
/* configure the canvas buffer */
|
|
if ((x2 - x1) && (y2 - y1))
|
|
core->canvas_buf = temp_buf_resize (core->canvas_buf, bytes,
|
|
x1, y1,
|
|
(x2 - x1), (y2 - y1));
|
|
else
|
|
return NULL;
|
|
|
|
return core->canvas_buf;
|
|
}
|
|
|
|
TempBuf *
|
|
gimp_paint_core_get_orig_image (GimpPaintCore *core,
|
|
GimpDrawable *drawable,
|
|
gint x1,
|
|
gint y1,
|
|
gint x2,
|
|
gint y2)
|
|
{
|
|
PixelRegion srcPR;
|
|
PixelRegion destPR;
|
|
Tile *undo_tile;
|
|
gint h;
|
|
gint refd;
|
|
gint pixelwidth;
|
|
gint dwidth;
|
|
gint dheight;
|
|
guchar *s;
|
|
guchar *d;
|
|
gpointer pr;
|
|
|
|
core->orig_buf = temp_buf_resize (core->orig_buf,
|
|
gimp_drawable_bytes (drawable),
|
|
x1, y1,
|
|
(x2 - x1), (y2 - y1));
|
|
|
|
dwidth = gimp_drawable_width (drawable);
|
|
dheight = gimp_drawable_height (drawable);
|
|
|
|
x1 = CLAMP (x1, 0, dwidth);
|
|
y1 = CLAMP (y1, 0, dheight);
|
|
x2 = CLAMP (x2, 0, dwidth);
|
|
y2 = CLAMP (y2, 0, dheight);
|
|
|
|
/* configure the pixel regions */
|
|
pixel_region_init (&srcPR, gimp_drawable_data (drawable),
|
|
x1, y1,
|
|
(x2 - x1), (y2 - y1),
|
|
FALSE);
|
|
|
|
destPR.bytes = core->orig_buf->bytes;
|
|
destPR.x = 0;
|
|
destPR.y = 0;
|
|
destPR.w = (x2 - x1);
|
|
destPR.h = (y2 - y1);
|
|
destPR.rowstride = core->orig_buf->bytes * core->orig_buf->width;
|
|
destPR.data = (temp_buf_data (core->orig_buf) +
|
|
(y1 - core->orig_buf->y) * destPR.rowstride +
|
|
(x1 - core->orig_buf->x) * destPR.bytes);
|
|
|
|
for (pr = pixel_regions_register (2, &srcPR, &destPR);
|
|
pr != NULL;
|
|
pr = pixel_regions_process (pr))
|
|
{
|
|
/* If the undo tile corresponding to this location is valid, use it */
|
|
undo_tile = tile_manager_get_tile (core->undo_tiles,
|
|
srcPR.x, srcPR.y,
|
|
FALSE, FALSE);
|
|
if (tile_is_valid (undo_tile) == TRUE)
|
|
{
|
|
refd = 1;
|
|
undo_tile = tile_manager_get_tile (core->undo_tiles,
|
|
srcPR.x, srcPR.y,
|
|
TRUE, FALSE);
|
|
s = (unsigned char*)tile_data_pointer (undo_tile, 0, 0) +
|
|
srcPR.rowstride * (srcPR.y % TILE_HEIGHT) +
|
|
srcPR.bytes * (srcPR.x % TILE_WIDTH); /* dubious... */
|
|
}
|
|
else
|
|
{
|
|
refd = 0;
|
|
s = srcPR.data;
|
|
}
|
|
|
|
d = destPR.data;
|
|
pixelwidth = srcPR.w * srcPR.bytes;
|
|
h = srcPR.h;
|
|
while (h --)
|
|
{
|
|
memcpy (d, s, pixelwidth);
|
|
s += srcPR.rowstride;
|
|
d += destPR.rowstride;
|
|
}
|
|
|
|
if (refd)
|
|
tile_release (undo_tile, FALSE);
|
|
}
|
|
|
|
return core->orig_buf;
|
|
}
|
|
|
|
void
|
|
gimp_paint_core_paste_canvas (GimpPaintCore *core,
|
|
GimpDrawable *drawable,
|
|
gdouble brush_opacity,
|
|
gdouble image_opacity,
|
|
GimpLayerModeEffects paint_mode,
|
|
GimpBrushApplicationMode brush_hardness,
|
|
gdouble brush_scale,
|
|
GimpPaintApplicationMode mode)
|
|
{
|
|
MaskBuf *brush_mask;
|
|
|
|
/* get the brush mask */
|
|
brush_mask = gimp_paint_core_get_brush_mask (core,
|
|
brush_hardness,
|
|
brush_scale);
|
|
|
|
/* paste the canvas buf */
|
|
gimp_paint_core_paste (core, brush_mask, drawable,
|
|
brush_opacity,
|
|
image_opacity, paint_mode,
|
|
mode);
|
|
}
|
|
|
|
/* Similar to gimp_paint_core_paste_canvas, but replaces the alpha channel
|
|
* rather than using it to composite (i.e. transparent over opaque
|
|
* becomes transparent rather than opauqe.
|
|
*/
|
|
void
|
|
gimp_paint_core_replace_canvas (GimpPaintCore *core,
|
|
GimpDrawable *drawable,
|
|
gdouble brush_opacity,
|
|
gdouble image_opacity,
|
|
GimpBrushApplicationMode brush_hardness,
|
|
gdouble brush_scale,
|
|
GimpPaintApplicationMode mode)
|
|
{
|
|
MaskBuf *brush_mask;
|
|
|
|
/* get the brush mask */
|
|
brush_mask = gimp_paint_core_get_brush_mask (core,
|
|
brush_hardness,
|
|
brush_scale);
|
|
|
|
/* paste the canvas buf */
|
|
gimp_paint_core_replace (core, brush_mask, drawable,
|
|
brush_opacity,
|
|
image_opacity, mode);
|
|
}
|
|
|
|
|
|
static void
|
|
gimp_paint_core_invalidate_cache (GimpBrush *brush,
|
|
GimpPaintCore *core)
|
|
{
|
|
/* Make sure we don't cache data for a brush that has changed */
|
|
|
|
if (core->last_brush_mask == brush->mask)
|
|
core->cache_invalid = TRUE;
|
|
}
|
|
|
|
/************************************************************
|
|
* LOCAL FUNCTION DEFINITIONS *
|
|
************************************************************/
|
|
|
|
static void
|
|
gimp_paint_core_calc_brush_size (GimpPaintCore *core,
|
|
MaskBuf *mask,
|
|
gdouble scale,
|
|
gint *width,
|
|
gint *height)
|
|
{
|
|
scale = CLAMP (scale, 0.0, 1.0);
|
|
|
|
if (! core->use_pressure)
|
|
{
|
|
*width = mask->width;
|
|
*height = mask->height;
|
|
}
|
|
else
|
|
{
|
|
gdouble ratio;
|
|
|
|
if (scale < 1 / 256)
|
|
ratio = 1 / 16;
|
|
else
|
|
ratio = sqrt (scale);
|
|
|
|
*width = MAX ((gint) (mask->width * ratio + 0.5), 1);
|
|
*height = MAX ((gint) (mask->height * ratio + 0.5), 1);
|
|
}
|
|
}
|
|
|
|
static MaskBuf *
|
|
gimp_paint_core_subsample_mask (GimpPaintCore *core,
|
|
MaskBuf *mask,
|
|
gdouble x,
|
|
gdouble y)
|
|
{
|
|
MaskBuf *dest;
|
|
gdouble left;
|
|
guchar *m;
|
|
guchar *d;
|
|
const gint *k;
|
|
gint index1;
|
|
gint index2;
|
|
const gint *kernel;
|
|
gint new_val;
|
|
gint i, j;
|
|
gint r, s;
|
|
|
|
x += (x < 0) ? mask->width : 0;
|
|
left = x - floor (x);
|
|
index1 = (gint) (left * (gdouble) (KERNEL_SUBSAMPLE + 1));
|
|
|
|
y += (y < 0) ? mask->height : 0;
|
|
left = y - floor (y);
|
|
index2 = (gint) (left * (gdouble) (KERNEL_SUBSAMPLE + 1));
|
|
|
|
kernel = subsample[index2][index1];
|
|
|
|
if (mask == core->last_brush_mask && ! core->cache_invalid)
|
|
{
|
|
if (core->kernel_brushes[index2][index1])
|
|
return core->kernel_brushes[index2][index1];
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i <= KERNEL_SUBSAMPLE; i++)
|
|
for (j = 0; j <= KERNEL_SUBSAMPLE; j++)
|
|
{
|
|
if (core->kernel_brushes[i][j])
|
|
{
|
|
mask_buf_free (core->kernel_brushes[i][j]);
|
|
core->kernel_brushes[i][j] = NULL;
|
|
}
|
|
}
|
|
|
|
core->last_brush_mask = mask;
|
|
core->cache_invalid = FALSE;
|
|
}
|
|
|
|
dest = mask_buf_new (mask->width + 2,
|
|
mask->height + 2);
|
|
|
|
core->kernel_brushes[index2][index1] = dest;
|
|
|
|
m = mask_buf_data (mask);
|
|
for (i = 0; i < mask->height; i++)
|
|
{
|
|
for (j = 0; j < mask->width; j++)
|
|
{
|
|
k = kernel;
|
|
for (r = 0; r < KERNEL_HEIGHT; r++)
|
|
{
|
|
d = mask_buf_data (dest) + (i+r) * dest->width + j;
|
|
s = KERNEL_WIDTH;
|
|
while (s--)
|
|
{
|
|
new_val = *d + ((*m * *k++ + 128) >> 8);
|
|
*d++ = MIN (new_val, 255);
|
|
}
|
|
}
|
|
m++;
|
|
}
|
|
}
|
|
|
|
return dest;
|
|
}
|
|
|
|
/* #define FANCY_PRESSURE */
|
|
|
|
static MaskBuf *
|
|
gimp_paint_core_pressurize_mask (GimpPaintCore *core,
|
|
MaskBuf *brush_mask,
|
|
gdouble x,
|
|
gdouble y,
|
|
gdouble pressure)
|
|
{
|
|
static guchar mapi[256];
|
|
guchar *source;
|
|
guchar *dest;
|
|
MaskBuf *subsample_mask;
|
|
gint i;
|
|
#ifdef FANCY_PRESSURE
|
|
static gdouble map[256];
|
|
gdouble ds, s, c;
|
|
#endif
|
|
|
|
/* Get the raw subsampled mask */
|
|
subsample_mask = gimp_paint_core_subsample_mask (core,
|
|
brush_mask,
|
|
x, y);
|
|
|
|
/* Special case pressure = 0.5 */
|
|
if ((int)(pressure * 100 + 0.5) == 50)
|
|
return subsample_mask;
|
|
|
|
if (core->pressure_brush)
|
|
mask_buf_free (core->pressure_brush);
|
|
|
|
core->pressure_brush = mask_buf_new (brush_mask->width + 2,
|
|
brush_mask->height + 2);
|
|
|
|
#ifdef FANCY_PRESSURE
|
|
/* Create the pressure profile
|
|
|
|
It is: I'(I) = tanh(20*(pressure-0.5)*I) : pressure > 0.5
|
|
I'(I) = 1 - tanh(20*(0.5-pressure)*(1-I)) : pressure < 0.5
|
|
|
|
It looks like:
|
|
|
|
low pressure medium pressure high pressure
|
|
|
|
| / --
|
|
| / /
|
|
/ / |
|
|
-- / |
|
|
|
|
*/
|
|
|
|
ds = (pressure - 0.5)*(20./256.);
|
|
s = 0;
|
|
c = 1.0;
|
|
|
|
if (ds > 0)
|
|
{
|
|
for (i=0;i<256;i++)
|
|
{
|
|
map[i] = s/c;
|
|
s += c*ds;
|
|
c += s*ds;
|
|
}
|
|
for (i=0;i<256;i++)
|
|
mapi[i] = (int)(255*map[i]/map[255]);
|
|
}
|
|
else
|
|
{
|
|
ds = -ds;
|
|
for (i=255;i>=0;i--)
|
|
{
|
|
map[i] = s/c;
|
|
s += c*ds;
|
|
c += s*ds;
|
|
}
|
|
for (i=0;i<256;i++)
|
|
mapi[i] = (int)(255*(1-map[i]/map[0]));
|
|
}
|
|
#else /* ! FANCY_PRESSURE */
|
|
|
|
for (i = 0; i < 256; i++)
|
|
{
|
|
gint tmp = (pressure / 0.5) * i;
|
|
|
|
if (tmp > 255)
|
|
mapi[i] = 255;
|
|
else
|
|
mapi[i] = tmp;
|
|
}
|
|
|
|
#endif /* FANCY_PRESSURE */
|
|
|
|
/* Now convert the brush */
|
|
|
|
source = mask_buf_data (subsample_mask);
|
|
dest = mask_buf_data (core->pressure_brush);
|
|
|
|
i = subsample_mask->width * subsample_mask->height;
|
|
while (i--)
|
|
{
|
|
*dest++ = mapi[(*source++)];
|
|
}
|
|
|
|
return core->pressure_brush;
|
|
}
|
|
|
|
static MaskBuf *
|
|
gimp_paint_core_solidify_mask (GimpPaintCore *core,
|
|
MaskBuf *brush_mask)
|
|
{
|
|
gint i;
|
|
gint j;
|
|
guchar *data;
|
|
guchar *src;
|
|
|
|
if (brush_mask == core->last_solid_brush &&
|
|
core->solid_brush &&
|
|
! core->cache_invalid)
|
|
{
|
|
return core->solid_brush;
|
|
}
|
|
|
|
core->last_solid_brush = brush_mask;
|
|
|
|
if (core->solid_brush)
|
|
mask_buf_free (core->solid_brush);
|
|
|
|
core->solid_brush = mask_buf_new (brush_mask->width + 2,
|
|
brush_mask->height + 2);
|
|
|
|
/* get the data and advance one line into it */
|
|
data = (mask_buf_data (core->solid_brush) +
|
|
core->solid_brush->width);
|
|
src = mask_buf_data (brush_mask);
|
|
|
|
for (i = 0; i < brush_mask->height; i++)
|
|
{
|
|
data++;
|
|
for (j = 0; j < brush_mask->width; j++)
|
|
{
|
|
*data++ = (*src++) ? OPAQUE_OPACITY : TRANSPARENT_OPACITY;
|
|
}
|
|
data++;
|
|
}
|
|
|
|
return core->solid_brush;
|
|
}
|
|
|
|
static MaskBuf *
|
|
gimp_paint_core_scale_mask (GimpPaintCore *core,
|
|
MaskBuf *brush_mask,
|
|
gdouble scale)
|
|
{
|
|
gint dest_width;
|
|
gint dest_height;
|
|
|
|
scale = CLAMP (scale, 0.0, 1.0);
|
|
|
|
if (scale == 0.0)
|
|
return NULL;
|
|
|
|
if (scale == 1.0)
|
|
return brush_mask;
|
|
|
|
gimp_paint_core_calc_brush_size (core,
|
|
brush_mask,
|
|
scale,
|
|
&dest_width, &dest_height);
|
|
|
|
if (brush_mask == core->last_scale_brush &&
|
|
core->scale_brush &&
|
|
! core->cache_invalid &&
|
|
dest_width == core->last_scale_width &&
|
|
dest_height == core->last_scale_height)
|
|
{
|
|
return core->scale_brush;
|
|
}
|
|
|
|
core->last_scale_brush = brush_mask;
|
|
core->last_scale_width = dest_width;
|
|
core->last_scale_height = dest_height;
|
|
|
|
if (core->scale_brush)
|
|
mask_buf_free (core->scale_brush);
|
|
|
|
core->scale_brush = brush_scale_mask (brush_mask,
|
|
dest_width, dest_height);
|
|
core->cache_invalid = TRUE;
|
|
|
|
return core->scale_brush;
|
|
}
|
|
|
|
static MaskBuf *
|
|
gimp_paint_core_scale_pixmap (GimpPaintCore *core,
|
|
MaskBuf *brush_mask,
|
|
gdouble scale)
|
|
{
|
|
gint dest_width;
|
|
gint dest_height;
|
|
|
|
scale = CLAMP (scale, 0.0, 1.0);
|
|
|
|
if (scale == 0.0)
|
|
return NULL;
|
|
|
|
if (scale == 1.0)
|
|
return brush_mask;
|
|
|
|
gimp_paint_core_calc_brush_size (core,
|
|
brush_mask,
|
|
scale,
|
|
&dest_width, &dest_height);
|
|
|
|
if (brush_mask == core->last_scale_pixmap &&
|
|
core->scale_pixmap &&
|
|
! core->cache_invalid &&
|
|
dest_width == core->last_scale_pixmap_width &&
|
|
dest_height == core->last_scale_pixmap_height)
|
|
{
|
|
return core->scale_pixmap;
|
|
}
|
|
|
|
core->last_scale_pixmap = brush_mask;
|
|
core->last_scale_pixmap_width = dest_width;
|
|
core->last_scale_pixmap_height = dest_height;
|
|
|
|
if (core->scale_pixmap)
|
|
mask_buf_free (core->scale_pixmap);
|
|
|
|
core->scale_pixmap = brush_scale_pixmap (brush_mask,
|
|
dest_width, dest_height);
|
|
core->cache_invalid = TRUE;
|
|
|
|
return core->scale_pixmap;
|
|
}
|
|
|
|
static MaskBuf *
|
|
gimp_paint_core_get_brush_mask (GimpPaintCore *core,
|
|
GimpBrushApplicationMode brush_hardness,
|
|
gdouble scale)
|
|
{
|
|
MaskBuf *mask;
|
|
|
|
if (core->use_pressure)
|
|
mask = gimp_paint_core_scale_mask (core, core->brush->mask, scale);
|
|
else
|
|
mask = core->brush->mask;
|
|
|
|
switch (brush_hardness)
|
|
{
|
|
case GIMP_BRUSH_SOFT:
|
|
mask = gimp_paint_core_subsample_mask (core, mask,
|
|
core->cur_coords.x,
|
|
core->cur_coords.y);
|
|
break;
|
|
|
|
case GIMP_BRUSH_HARD:
|
|
mask = gimp_paint_core_solidify_mask (core, mask);
|
|
break;
|
|
|
|
case GIMP_BRUSH_PRESSURE:
|
|
if (core->use_pressure)
|
|
mask = gimp_paint_core_pressurize_mask (core, mask,
|
|
core->cur_coords.x,
|
|
core->cur_coords.y,
|
|
core->cur_coords.pressure);
|
|
else
|
|
mask = gimp_paint_core_subsample_mask (core, mask,
|
|
core->cur_coords.x,
|
|
core->cur_coords.y);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return mask;
|
|
}
|
|
|
|
static void
|
|
gimp_paint_core_paste (GimpPaintCore *core,
|
|
MaskBuf *brush_mask,
|
|
GimpDrawable *drawable,
|
|
gdouble brush_opacity,
|
|
gdouble image_opacity,
|
|
GimpLayerModeEffects paint_mode,
|
|
GimpPaintApplicationMode mode)
|
|
{
|
|
GimpImage *gimage;
|
|
PixelRegion srcPR;
|
|
TileManager *alt = NULL;
|
|
gint offx;
|
|
gint offy;
|
|
|
|
gimage = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
|
|
/* set undo blocks */
|
|
set_undo_tiles (core,
|
|
drawable,
|
|
core->canvas_buf->x, core->canvas_buf->y,
|
|
core->canvas_buf->width, core->canvas_buf->height);
|
|
|
|
/* If the mode is CONSTANT:
|
|
* combine the canvas buf, the brush mask to the canvas tiles
|
|
*/
|
|
if (mode == GIMP_PAINT_CONSTANT)
|
|
{
|
|
/* initialize any invalid canvas tiles */
|
|
set_canvas_tiles (core,
|
|
core->canvas_buf->x,
|
|
core->canvas_buf->y,
|
|
core->canvas_buf->width,
|
|
core->canvas_buf->height);
|
|
|
|
brush_to_canvas_tiles (core, brush_mask, brush_opacity);
|
|
canvas_tiles_to_canvas_buf (core);
|
|
alt = core->undo_tiles;
|
|
}
|
|
/* Otherwise:
|
|
* combine the canvas buf and the brush mask to the canvas buf
|
|
*/
|
|
else
|
|
{
|
|
brush_to_canvas_buf (core, brush_mask, brush_opacity);
|
|
}
|
|
|
|
/* intialize canvas buf source pixel regions */
|
|
srcPR.bytes = core->canvas_buf->bytes;
|
|
srcPR.x = 0;
|
|
srcPR.y = 0;
|
|
srcPR.w = core->canvas_buf->width;
|
|
srcPR.h = core->canvas_buf->height;
|
|
srcPR.rowstride = core->canvas_buf->width * core->canvas_buf->bytes;
|
|
srcPR.data = temp_buf_data (core->canvas_buf);
|
|
|
|
/* apply the paint area to the gimage */
|
|
gimp_image_apply_image (gimage, drawable, &srcPR,
|
|
FALSE,
|
|
image_opacity, paint_mode,
|
|
alt, /* specify an alternative src1 */
|
|
core->canvas_buf->x,
|
|
core->canvas_buf->y);
|
|
|
|
/* Update the undo extents */
|
|
core->x1 = MIN (core->x1, core->canvas_buf->x);
|
|
core->y1 = MIN (core->y1, core->canvas_buf->y);
|
|
core->x2 = MAX (core->x2, core->canvas_buf->x + core->canvas_buf->width);
|
|
core->y2 = MAX (core->y2, core->canvas_buf->y + core->canvas_buf->height);
|
|
|
|
/* Update the gimage--it is important to call gimp_image_update
|
|
* instead of drawable_update because we don't want the drawable
|
|
* preview to be constantly invalidated
|
|
*/
|
|
gimp_drawable_offsets (drawable, &offx, &offy);
|
|
gimp_image_update (gimage,
|
|
core->canvas_buf->x + offx,
|
|
core->canvas_buf->y + offy,
|
|
core->canvas_buf->width,
|
|
core->canvas_buf->height);
|
|
}
|
|
|
|
/* This works similarly to gimp_paint_core_paste. However, instead of
|
|
* combining the canvas to the paint core drawable using one of the
|
|
* combination modes, it uses a "replace" mode (i.e. transparent
|
|
* pixels in the canvas erase the paint core drawable).
|
|
|
|
* When not drawing on alpha-enabled images, it just paints using
|
|
* NORMAL mode.
|
|
*/
|
|
static void
|
|
gimp_paint_core_replace (GimpPaintCore *core,
|
|
MaskBuf *brush_mask,
|
|
GimpDrawable *drawable,
|
|
gdouble brush_opacity,
|
|
gdouble image_opacity,
|
|
GimpPaintApplicationMode mode)
|
|
{
|
|
GimpImage *gimage;
|
|
PixelRegion srcPR;
|
|
PixelRegion maskPR;
|
|
TileManager *alt = NULL;
|
|
gint offx;
|
|
gint offy;
|
|
|
|
if (! gimp_drawable_has_alpha (drawable))
|
|
{
|
|
gimp_paint_core_paste (core, brush_mask, drawable,
|
|
brush_opacity,
|
|
image_opacity, GIMP_NORMAL_MODE,
|
|
mode);
|
|
return;
|
|
}
|
|
|
|
gimage = gimp_item_get_image (GIMP_ITEM (drawable));
|
|
|
|
/* set undo blocks */
|
|
set_undo_tiles (core,
|
|
drawable,
|
|
core->canvas_buf->x,
|
|
core->canvas_buf->y,
|
|
core->canvas_buf->width,
|
|
core->canvas_buf->height);
|
|
|
|
if (mode == GIMP_PAINT_CONSTANT)
|
|
{
|
|
/* initialize any invalid canvas tiles */
|
|
set_canvas_tiles (core,
|
|
core->canvas_buf->x,
|
|
core->canvas_buf->y,
|
|
core->canvas_buf->width,
|
|
core->canvas_buf->height);
|
|
|
|
/* combine the brush mask and the canvas tiles */
|
|
brush_to_canvas_tiles (core, brush_mask, brush_opacity);
|
|
|
|
/* set the alt source as the unaltered undo_tiles */
|
|
alt = core->undo_tiles;
|
|
|
|
/* initialize the maskPR from the canvas tiles */
|
|
pixel_region_init (&maskPR, core->canvas_tiles,
|
|
core->canvas_buf->x,
|
|
core->canvas_buf->y,
|
|
core->canvas_buf->width,
|
|
core->canvas_buf->height,
|
|
FALSE);
|
|
}
|
|
else
|
|
{
|
|
/* The mask is just the brush mask */
|
|
maskPR.bytes = 1;
|
|
maskPR.x = 0;
|
|
maskPR.y = 0;
|
|
maskPR.w = core->canvas_buf->width;
|
|
maskPR.h = core->canvas_buf->height;
|
|
maskPR.rowstride = maskPR.bytes * brush_mask->width;
|
|
maskPR.data = mask_buf_data (brush_mask);
|
|
}
|
|
|
|
/* intialize canvas buf source pixel regions */
|
|
srcPR.bytes = core->canvas_buf->bytes;
|
|
srcPR.x = 0;
|
|
srcPR.y = 0;
|
|
srcPR.w = core->canvas_buf->width;
|
|
srcPR.h = core->canvas_buf->height;
|
|
srcPR.rowstride = core->canvas_buf->width * core->canvas_buf->bytes;
|
|
srcPR.data = temp_buf_data (core->canvas_buf);
|
|
|
|
/* apply the paint area to the gimage */
|
|
gimp_image_replace_image (gimage, drawable, &srcPR,
|
|
FALSE,
|
|
image_opacity,
|
|
&maskPR,
|
|
core->canvas_buf->x,
|
|
core->canvas_buf->y);
|
|
|
|
/* Update the undo extents */
|
|
core->x1 = MIN (core->x1, core->canvas_buf->x);
|
|
core->y1 = MIN (core->y1, core->canvas_buf->y);
|
|
core->x2 = MAX (core->x2, core->canvas_buf->x + core->canvas_buf->width) ;
|
|
core->y2 = MAX (core->y2, core->canvas_buf->y + core->canvas_buf->height) ;
|
|
|
|
/* Update the gimage--it is important to call gimp_image_update
|
|
* instead of drawable_update because we don't want the drawable
|
|
* preview to be constantly invalidated
|
|
*/
|
|
gimp_drawable_offsets (drawable, &offx, &offy);
|
|
gimp_image_update (gimage,
|
|
core->canvas_buf->x + offx,
|
|
core->canvas_buf->y + offy,
|
|
core->canvas_buf->width,
|
|
core->canvas_buf->height);
|
|
}
|
|
|
|
static void
|
|
canvas_tiles_to_canvas_buf (GimpPaintCore *core)
|
|
{
|
|
PixelRegion srcPR;
|
|
PixelRegion maskPR;
|
|
|
|
/* combine the canvas tiles and the canvas buf */
|
|
srcPR.bytes = core->canvas_buf->bytes;
|
|
srcPR.x = 0;
|
|
srcPR.y = 0;
|
|
srcPR.w = core->canvas_buf->width;
|
|
srcPR.h = core->canvas_buf->height;
|
|
srcPR.rowstride = core->canvas_buf->width * core->canvas_buf->bytes;
|
|
srcPR.data = temp_buf_data (core->canvas_buf);
|
|
|
|
pixel_region_init (&maskPR, core->canvas_tiles,
|
|
core->canvas_buf->x,
|
|
core->canvas_buf->y,
|
|
core->canvas_buf->width,
|
|
core->canvas_buf->height,
|
|
FALSE);
|
|
|
|
/* apply the canvas tiles to the canvas buf */
|
|
apply_mask_to_region (&srcPR, &maskPR, OPAQUE_OPACITY);
|
|
}
|
|
|
|
static void
|
|
brush_to_canvas_tiles (GimpPaintCore *core,
|
|
MaskBuf *brush_mask,
|
|
gdouble brush_opacity)
|
|
{
|
|
PixelRegion srcPR;
|
|
PixelRegion maskPR;
|
|
gint x;
|
|
gint y;
|
|
gint xoff;
|
|
gint yoff;
|
|
|
|
/* combine the brush mask and the canvas tiles */
|
|
pixel_region_init (&srcPR, core->canvas_tiles,
|
|
core->canvas_buf->x,
|
|
core->canvas_buf->y,
|
|
core->canvas_buf->width,
|
|
core->canvas_buf->height,
|
|
TRUE);
|
|
|
|
x = (gint) floor (core->cur_coords.x) - (brush_mask->width >> 1);
|
|
y = (gint) floor (core->cur_coords.y) - (brush_mask->height >> 1);
|
|
xoff = (x < 0) ? -x : 0;
|
|
yoff = (y < 0) ? -y : 0;
|
|
|
|
maskPR.bytes = 1;
|
|
maskPR.x = 0;
|
|
maskPR.y = 0;
|
|
maskPR.w = srcPR.w;
|
|
maskPR.h = srcPR.h;
|
|
maskPR.rowstride = maskPR.bytes * brush_mask->width;
|
|
maskPR.data = mask_buf_data (brush_mask) + (yoff * maskPR.rowstride +
|
|
xoff * maskPR.bytes);
|
|
|
|
/* combine the mask to the canvas tiles */
|
|
combine_mask_and_region (&srcPR, &maskPR, brush_opacity * 255.999);
|
|
}
|
|
|
|
static void
|
|
brush_to_canvas_buf (GimpPaintCore *core,
|
|
MaskBuf *brush_mask,
|
|
gdouble brush_opacity)
|
|
{
|
|
PixelRegion srcPR;
|
|
PixelRegion maskPR;
|
|
gint x;
|
|
gint y;
|
|
gint xoff;
|
|
gint yoff;
|
|
|
|
x = (gint) floor (core->cur_coords.x) - (brush_mask->width >> 1);
|
|
y = (gint) floor (core->cur_coords.y) - (brush_mask->height >> 1);
|
|
xoff = (x < 0) ? -x : 0;
|
|
yoff = (y < 0) ? -y : 0;
|
|
|
|
/* combine the canvas buf and the brush mask to the canvas buf */
|
|
srcPR.bytes = core->canvas_buf->bytes;
|
|
srcPR.x = 0;
|
|
srcPR.y = 0;
|
|
srcPR.w = core->canvas_buf->width;
|
|
srcPR.h = core->canvas_buf->height;
|
|
srcPR.rowstride = core->canvas_buf->width * core->canvas_buf->bytes;
|
|
srcPR.data = temp_buf_data (core->canvas_buf);
|
|
|
|
maskPR.bytes = 1;
|
|
maskPR.x = 0;
|
|
maskPR.y = 0;
|
|
maskPR.w = srcPR.w;
|
|
maskPR.h = srcPR.h;
|
|
maskPR.rowstride = maskPR.bytes * brush_mask->width;
|
|
maskPR.data = mask_buf_data (brush_mask) + yoff * maskPR.rowstride + xoff * maskPR.bytes;
|
|
|
|
/* apply the mask */
|
|
apply_mask_to_region (&srcPR, &maskPR, brush_opacity * 255.999);
|
|
}
|
|
|
|
static void
|
|
set_undo_tiles (GimpPaintCore *core,
|
|
GimpDrawable *drawable,
|
|
gint x,
|
|
gint y,
|
|
gint w,
|
|
gint h)
|
|
{
|
|
gint i;
|
|
gint j;
|
|
Tile *src_tile;
|
|
Tile *dest_tile;
|
|
|
|
if (! core->undo_tiles)
|
|
{
|
|
g_warning ("set_undo_tiles: undo_tiles is null");
|
|
return;
|
|
}
|
|
|
|
for (i = y; i < (y + h); i += (TILE_HEIGHT - (i % TILE_HEIGHT)))
|
|
{
|
|
for (j = x; j < (x + w); j += (TILE_WIDTH - (j % TILE_WIDTH)))
|
|
{
|
|
dest_tile = tile_manager_get_tile (core->undo_tiles, j, i,
|
|
FALSE, FALSE);
|
|
|
|
if (tile_is_valid (dest_tile) == FALSE)
|
|
{
|
|
src_tile = tile_manager_get_tile (gimp_drawable_data (drawable),
|
|
j, i, TRUE, FALSE);
|
|
tile_manager_map_tile (core->undo_tiles, j, i, src_tile);
|
|
tile_release (src_tile, FALSE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
set_canvas_tiles (GimpPaintCore *core,
|
|
gint x,
|
|
gint y,
|
|
gint w,
|
|
gint h)
|
|
{
|
|
gint i;
|
|
gint j;
|
|
Tile *tile;
|
|
|
|
for (i = y; i < (y + h); i += (TILE_HEIGHT - (i % TILE_HEIGHT)))
|
|
{
|
|
for (j = x; j < (x + w); j += (TILE_WIDTH - (j % TILE_WIDTH)))
|
|
{
|
|
tile = tile_manager_get_tile (core->canvas_tiles, j, i,
|
|
FALSE, FALSE);
|
|
|
|
if (tile_is_valid (tile) == FALSE)
|
|
{
|
|
tile = tile_manager_get_tile (core->canvas_tiles, j, i,
|
|
TRUE, TRUE);
|
|
memset (tile_data_pointer (tile, 0, 0), 0, tile_size (tile));
|
|
tile_release (tile, TRUE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**************************************************/
|
|
/* Brush pipe utility functions */
|
|
/**************************************************/
|
|
|
|
void
|
|
gimp_paint_core_color_area_with_pixmap (GimpPaintCore *core,
|
|
GimpImage *dest,
|
|
GimpDrawable *drawable,
|
|
TempBuf *area,
|
|
gdouble scale,
|
|
GimpBrushApplicationMode mode)
|
|
{
|
|
PixelRegion destPR;
|
|
void *pr;
|
|
guchar *d;
|
|
gint ulx;
|
|
gint uly;
|
|
gint offsetx;
|
|
gint offsety;
|
|
gint y;
|
|
TempBuf *pixmap_mask;
|
|
TempBuf *brush_mask;
|
|
|
|
g_return_if_fail (GIMP_IS_BRUSH (core->brush));
|
|
g_return_if_fail (core->brush->pixmap != NULL);
|
|
|
|
/* scale the brushes */
|
|
pixmap_mask = gimp_paint_core_scale_pixmap (core,
|
|
core->brush->pixmap,
|
|
scale);
|
|
|
|
if (mode == GIMP_BRUSH_SOFT)
|
|
brush_mask = gimp_paint_core_scale_mask (core,
|
|
core->brush->mask,
|
|
scale);
|
|
else
|
|
brush_mask = NULL;
|
|
|
|
destPR.bytes = area->bytes;
|
|
destPR.x = 0;
|
|
destPR.y = 0;
|
|
destPR.w = area->width;
|
|
destPR.h = area->height;
|
|
destPR.rowstride = destPR.bytes * area->width;
|
|
destPR.data = temp_buf_data (area);
|
|
|
|
pr = pixel_regions_register (1, &destPR);
|
|
|
|
/* Calculate upper left corner of brush as in
|
|
* gimp_paint_core_get_paint_area. Ugly to have to do this here, too.
|
|
*/
|
|
|
|
ulx = (gint) floor (core->cur_coords.x) - (pixmap_mask->width >> 1);
|
|
uly = (gint) floor (core->cur_coords.y) - (pixmap_mask->height >> 1);
|
|
|
|
offsetx = area->x - ulx;
|
|
offsety = area->y - uly;
|
|
|
|
for (; pr != NULL; pr = pixel_regions_process (pr))
|
|
{
|
|
d = destPR.data;
|
|
for (y = 0; y < destPR.h; y++)
|
|
{
|
|
paint_line_pixmap_mask (dest, drawable, pixmap_mask, brush_mask,
|
|
d, offsetx, y + offsety,
|
|
destPR.bytes, destPR.w, mode);
|
|
d += destPR.rowstride;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
paint_line_pixmap_mask (GimpImage *dest,
|
|
GimpDrawable *drawable,
|
|
TempBuf *pixmap_mask,
|
|
TempBuf *brush_mask,
|
|
guchar *d,
|
|
gint x,
|
|
gint y,
|
|
gint bytes,
|
|
gint width,
|
|
GimpBrushApplicationMode mode)
|
|
{
|
|
guchar *b;
|
|
guchar *p;
|
|
guchar *mask;
|
|
gdouble alpha;
|
|
gdouble factor = 0.00392156986; /* 1.0 / 255.0 */
|
|
gint x_index;
|
|
gint i,byte_loop;
|
|
|
|
/* Make sure x, y are positive */
|
|
while (x < 0)
|
|
x += pixmap_mask->width;
|
|
while (y < 0)
|
|
y += pixmap_mask->height;
|
|
|
|
/* Point to the approriate scanline */
|
|
b = temp_buf_data (pixmap_mask) +
|
|
(y % pixmap_mask->height) * pixmap_mask->width * pixmap_mask->bytes;
|
|
|
|
if (mode == GIMP_BRUSH_SOFT && brush_mask)
|
|
{
|
|
/* ditto, except for the brush mask,
|
|
so we can pre-multiply the alpha value */
|
|
mask = temp_buf_data (brush_mask) +
|
|
(y % brush_mask->height) * brush_mask->width;
|
|
for (i = 0; i < width; i++)
|
|
{
|
|
/* attempt to avoid doing this calc twice in the loop */
|
|
x_index = ((i + x) % pixmap_mask->width);
|
|
p = b + x_index * pixmap_mask->bytes;
|
|
d[bytes-1] = mask[x_index];
|
|
|
|
/* multiply alpha into the pixmap data
|
|
* maybe we could do this at tool creation or brush switch time?
|
|
* and compute it for the whole brush at once and cache it?
|
|
*/
|
|
alpha = d[bytes-1] * factor;
|
|
if (alpha)
|
|
for (byte_loop = 0; byte_loop < bytes - 1; byte_loop++)
|
|
d[byte_loop] *= alpha;
|
|
|
|
/* printf("i: %i d->r: %i d->g: %i d->b: %i d->a: %i\n",i,(int)d[0], (int)d[1], (int)d[2], (int)d[3]); */
|
|
gimp_image_transform_color (dest, drawable, p, d, GIMP_RGB);
|
|
d += bytes;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < width; i++)
|
|
{
|
|
/* attempt to avoid doing this calc twice in the loop */
|
|
x_index = ((i + x) % pixmap_mask->width);
|
|
p = b + x_index * pixmap_mask->bytes;
|
|
d[bytes-1] = 255;
|
|
|
|
/* multiply alpha into the pixmap data */
|
|
/* maybe we could do this at tool creation or brush switch time? */
|
|
/* and compute it for the whole brush at once and cache it? */
|
|
gimp_image_transform_color (dest, drawable, p, d, GIMP_RGB);
|
|
d += bytes;
|
|
}
|
|
}
|
|
}
|