paint-funcs

paint-funcs

Synopsis




void                paint_funcs_setup                   (void);
void                paint_funcs_free                    (void);
void                color_pixels                        (guchar *dest,
                                                         const guchar *color,
                                                         guint w,
                                                         guint bytes);
void                color_pixels_mask                   (guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *color,
                                                         guint w,
                                                         guint bytes);
void                pattern_pixels_mask                 (guchar *dest,
                                                         const guchar *mask,
                                                         TempBuf *pattern,
                                                         guint w,
                                                         guint bytes,
                                                         gint x,
                                                         gint y);
void                blend_pixels                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         guchar blend,
                                                         guint w,
                                                         guint bytes);
void                shade_pixels                        (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *color,
                                                         guchar rblend,
                                                         guint w,
                                                         guint bytes,
                                                         gboolean has_alpha);
void                extract_alpha_pixels                (const guchar *src,
                                                         const guchar *mask,
                                                         guchar *dest,
                                                         guint w,
                                                         guint bytes);
void                swap_pixels                         (guchar *src,
                                                         guchar *dest,
                                                         guint length);
void                scale_pixels                        (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         gint scale);
void                add_alpha_pixels                    (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);
void                flatten_pixels                      (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *bg,
                                                         guint length,
                                                         guint bytes);
void                gray_to_rgb_pixels                  (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);
void                apply_mask_to_alpha_channel         (guchar *src,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);
void                combine_mask_and_alpha_channel_stipple
                                                        (guchar *src,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);
void                combine_mask_and_alpha_channel_stroke
                                                        (guchar *src,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);
void                copy_gray_to_inten_a_pixels         (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);
void                copy_color                          (PixelRegion *src,
                                                         PixelRegion *dest);
void                copy_color_pixels                   (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);
void                copy_component_pixels               (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes,
                                                         guint pixel);
void                initial_channel_pixels              (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);
void                initial_indexed_pixels              (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *cmap,
                                                         guint length);
void                initial_indexed_a_pixels            (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *no_mask,
                                                         const guchar *cmap,
                                                         guint opacity,
                                                         guint length);
void                initial_inten_pixels                (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *no_mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);
void                initial_inten_a_pixels              (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);
void                combine_indexed_and_indexed_pixels  (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);
void                combine_indexed_and_indexed_a_pixels
                                                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gint *affect,
                                                         guint length,
                                                         guint bytes);
void                combine_indexed_a_and_indexed_a_pixels
                                                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_a_and_indexed_pixels  (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *cmap,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_a_and_indexed_a_pixels
                                                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *cmap,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_and_inten_pixels      (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_and_inten_a_pixels    (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_a_and_inten_pixels    (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         gboolean mode_affect,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_a_and_inten_a_pixels  (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         gboolean mode_affect,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_a_and_channel_mask_pixels
                                                        (const guchar *src,
                                                         const guchar *channel,
                                                         guchar *dest,
                                                         const guchar *col,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);
void                combine_inten_a_and_channel_selection_pixels
                                                        (const guchar *src,
                                                         const guchar *channel,
                                                         guchar *dest,
                                                         const guchar *col,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);
void                extract_from_inten_pixels           (guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *bg,
                                                         gboolean cut,
                                                         guint length,
                                                         guint src_bytes,
                                                         guint dest_bytes);
void                extract_from_indexed_pixels         (guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *cmap,
                                                         const guchar *bg,
                                                         gboolean cut,
                                                         guint length,
                                                         guint src_bytes,
                                                         guint dest_bytes);
void                color_region                        (PixelRegion *dest,
                                                         const guchar *color);
void                color_region_mask                   (PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *color);
void                pattern_region                      (PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         TempBuf *pattern,
                                                         gint off_x,
                                                         gint off_y);
void                blend_region                        (PixelRegion *src1,
                                                         PixelRegion *src2,
                                                         PixelRegion *dest,
                                                         guchar blend);
void                shade_region                        (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         guchar *color,
                                                         guchar blend);
void                copy_region                         (PixelRegion *src,
                                                         PixelRegion *dest);
void                copy_region_nocow                   (PixelRegion *src,
                                                         PixelRegion *dest);
void                add_alpha_region                    (PixelRegion *src,
                                                         PixelRegion *dest);
void                flatten_region                      (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         guchar *bg);
void                extract_alpha_region                (PixelRegion *src,
                                                         PixelRegion *mask,
                                                         PixelRegion *dest);
void                extract_from_region                 (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *cmap,
                                                         const guchar *bg,
                                                         GimpImageBaseType type,
                                                         gboolean cut);
void                convolve_region                     (PixelRegion *srcR,
                                                         PixelRegion *destR,
                                                         const gfloat *matrix,
                                                         gint size,
                                                         gdouble divisor,
                                                         GimpConvolutionType mode,
                                                         gboolean alpha_weighting);
void                multiply_alpha_region               (PixelRegion *srcR);
void                separate_alpha_region               (PixelRegion *srcR);
void                gaussian_blur_region                (PixelRegion *srcR,
                                                         gdouble radius_x,
                                                         gdouble radius_y);
void                border_region                       (PixelRegion *src,
                                                         gint16 xradius,
                                                         gint16 yradius,
                                                         gboolean feather,
                                                         gboolean edge_lock);
gfloat              shapeburst_region                   (PixelRegion *srcPR,
                                                         PixelRegion *distPR,
                                                         GimpProgressFunc progress_callback,
                                                         gpointer progress_data);
void                thin_region                         (PixelRegion *region,
                                                         gint16 xradius,
                                                         gint16 yradius,
                                                         gboolean edge_lock);
void                fatten_region                       (PixelRegion *region,
                                                         gint16 xradius,
                                                         gint16 yradius);
void                smooth_region                       (PixelRegion *region);
void                erode_region                        (PixelRegion *region);
void                dilate_region                       (PixelRegion *region);
void                swap_region                         (PixelRegion *src,
                                                         PixelRegion *dest);
void                apply_mask_to_region                (PixelRegion *src,
                                                         PixelRegion *mask,
                                                         guint opacity);
void                combine_mask_and_region             (PixelRegion *src,
                                                         PixelRegion *mask,
                                                         guint opacity,
                                                         gboolean stipple);
void                copy_gray_to_region                 (PixelRegion *src,
                                                         PixelRegion *dest);
void                copy_component                      (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         guint pixel);
void                initial_region                      (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *data,
                                                         guint opacity,
                                                         GimpLayerModeEffects mode,
                                                         const gboolean *affect,
                                                         InitialMode type);
void                combine_regions                     (PixelRegion *src1,
                                                         PixelRegion *src2,
                                                         PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *data,
                                                         guint opacity,
                                                         GimpLayerModeEffects mode,
                                                         const gboolean *affect,
                                                         CombinationMode type);
void                combine_regions_replace             (PixelRegion *src1,
                                                         PixelRegion *src2,
                                                         PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *data,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         CombinationMode type);

Description

Details

paint_funcs_setup ()

void                paint_funcs_setup                   (void);


paint_funcs_free ()

void                paint_funcs_free                    (void);


color_pixels ()

void                color_pixels                        (guchar *dest,
                                                         const guchar *color,
                                                         guint w,
                                                         guint bytes);

dest :

color :

w :

bytes :


color_pixels_mask ()

void                color_pixels_mask                   (guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *color,
                                                         guint w,
                                                         guint bytes);

dest :

mask :

color :

w :

bytes :


pattern_pixels_mask ()

void                pattern_pixels_mask                 (guchar *dest,
                                                         const guchar *mask,
                                                         TempBuf *pattern,
                                                         guint w,
                                                         guint bytes,
                                                         gint x,
                                                         gint y);

dest :

mask :

pattern :

w :

bytes :

x :

y :


blend_pixels ()

void                blend_pixels                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         guchar blend,
                                                         guint w,
                                                         guint bytes);

src1 :

src2 :

dest :

blend :

w :

bytes :


shade_pixels ()

void                shade_pixels                        (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *color,
                                                         guchar rblend,
                                                         guint w,
                                                         guint bytes,
                                                         gboolean has_alpha);

src :

dest :

color :

rblend :

w :

bytes :

has_alpha :


extract_alpha_pixels ()

void                extract_alpha_pixels                (const guchar *src,
                                                         const guchar *mask,
                                                         guchar *dest,
                                                         guint w,
                                                         guint bytes);

src :

mask :

dest :

w :

bytes :


swap_pixels ()

void                swap_pixels                         (guchar *src,
                                                         guchar *dest,
                                                         guint length);

src :

dest :

length :


scale_pixels ()

void                scale_pixels                        (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         gint scale);

src :

dest :

length :

scale :


add_alpha_pixels ()

void                add_alpha_pixels                    (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);

src :

dest :

length :

bytes :


flatten_pixels ()

void                flatten_pixels                      (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *bg,
                                                         guint length,
                                                         guint bytes);

src :

dest :

bg :

length :

bytes :


gray_to_rgb_pixels ()

void                gray_to_rgb_pixels                  (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);

src :

dest :

length :

bytes :


apply_mask_to_alpha_channel ()

void                apply_mask_to_alpha_channel         (guchar *src,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);

src :

mask :

opacity :

length :

bytes :


combine_mask_and_alpha_channel_stipple ()

void                combine_mask_and_alpha_channel_stipple
                                                        (guchar *src,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);

src :

mask :

opacity :

length :

bytes :


combine_mask_and_alpha_channel_stroke ()

void                combine_mask_and_alpha_channel_stroke
                                                        (guchar *src,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);

src :

mask :

opacity :

length :

bytes :


copy_gray_to_inten_a_pixels ()

void                copy_gray_to_inten_a_pixels         (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);

src :

dest :

length :

bytes :


copy_color ()

void                copy_color                          (PixelRegion *src,
                                                         PixelRegion *dest);

src :

dest :


copy_color_pixels ()

void                copy_color_pixels                   (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);

src :

dest :

length :

bytes :


copy_component_pixels ()

void                copy_component_pixels               (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes,
                                                         guint pixel);

src :

dest :

length :

bytes :

pixel :


initial_channel_pixels ()

void                initial_channel_pixels              (const guchar *src,
                                                         guchar *dest,
                                                         guint length,
                                                         guint bytes);

src :

dest :

length :

bytes :


initial_indexed_pixels ()

void                initial_indexed_pixels              (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *cmap,
                                                         guint length);

src :

dest :

cmap :

length :


initial_indexed_a_pixels ()

void                initial_indexed_a_pixels            (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *no_mask,
                                                         const guchar *cmap,
                                                         guint opacity,
                                                         guint length);

src :

dest :

mask :

no_mask :

cmap :

opacity :

length :


initial_inten_pixels ()

void                initial_inten_pixels                (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *no_mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);

src :

dest :

mask :

no_mask :

opacity :

affect :

length :

bytes :


initial_inten_a_pixels ()

void                initial_inten_a_pixels              (const guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);

src :

dest :

mask :

opacity :

affect :

length :

bytes :


combine_indexed_and_indexed_pixels ()

void                combine_indexed_and_indexed_pixels  (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);

src1 :

src2 :

dest :

mask :

opacity :

affect :

length :

bytes :


combine_indexed_and_indexed_a_pixels ()

void                combine_indexed_and_indexed_a_pixels
                                                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gint *affect,
                                                         guint length,
                                                         guint bytes);

src1 :

src2 :

dest :

mask :

opacity :

affect :

length :

bytes :


combine_indexed_a_and_indexed_a_pixels ()

void                combine_indexed_a_and_indexed_a_pixels
                                                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);

src1 :

src2 :

dest :

mask :

opacity :

affect :

length :

bytes :


combine_inten_a_and_indexed_pixels ()

void                combine_inten_a_and_indexed_pixels  (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *cmap,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);

src1 :

src2 :

dest :

mask :

cmap :

opacity :

length :

bytes :


combine_inten_a_and_indexed_a_pixels ()

void                combine_inten_a_and_indexed_a_pixels
                                                        (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *cmap,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);

src1 :

src2 :

dest :

mask :

cmap :

opacity :

length :

bytes :


combine_inten_and_inten_pixels ()

void                combine_inten_and_inten_pixels      (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);

src1 :

src2 :

dest :

mask :

opacity :

affect :

length :

bytes :


combine_inten_and_inten_a_pixels ()

void                combine_inten_and_inten_a_pixels    (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         guint length,
                                                         guint bytes);

src1 :

src2 :

dest :

mask :

opacity :

affect :

length :

bytes :


combine_inten_a_and_inten_pixels ()

void                combine_inten_a_and_inten_pixels    (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         gboolean mode_affect,
                                                         guint length,
                                                         guint bytes);

src1 :

src2 :

dest :

mask :

opacity :

affect :

mode_affect :

length :

bytes :


combine_inten_a_and_inten_a_pixels ()

void                combine_inten_a_and_inten_a_pixels  (const guchar *src1,
                                                         const guchar *src2,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         guint opacity,
                                                         const gboolean *affect,
                                                         gboolean mode_affect,
                                                         guint length,
                                                         guint bytes);

src1 :

src2 :

dest :

mask :

opacity :

affect :

mode_affect :

length :

bytes :


combine_inten_a_and_channel_mask_pixels ()

void                combine_inten_a_and_channel_mask_pixels
                                                        (const guchar *src,
                                                         const guchar *channel,
                                                         guchar *dest,
                                                         const guchar *col,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);

src :

channel :

dest :

col :

opacity :

length :

bytes :


combine_inten_a_and_channel_selection_pixels ()

void                combine_inten_a_and_channel_selection_pixels
                                                        (const guchar *src,
                                                         const guchar *channel,
                                                         guchar *dest,
                                                         const guchar *col,
                                                         guint opacity,
                                                         guint length,
                                                         guint bytes);

src :

channel :

dest :

col :

opacity :

length :

bytes :


extract_from_inten_pixels ()

void                extract_from_inten_pixels           (guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *bg,
                                                         gboolean cut,
                                                         guint length,
                                                         guint src_bytes,
                                                         guint dest_bytes);

src :

dest :

mask :

bg :

cut :

length :

src_bytes :

dest_bytes :


extract_from_indexed_pixels ()

void                extract_from_indexed_pixels         (guchar *src,
                                                         guchar *dest,
                                                         const guchar *mask,
                                                         const guchar *cmap,
                                                         const guchar *bg,
                                                         gboolean cut,
                                                         guint length,
                                                         guint src_bytes,
                                                         guint dest_bytes);

src :

dest :

mask :

cmap :

bg :

cut :

length :

src_bytes :

dest_bytes :


color_region ()

void                color_region                        (PixelRegion *dest,
                                                         const guchar *color);

dest :

color :


color_region_mask ()

void                color_region_mask                   (PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         const guchar *color);

dest :

mask :

color :


pattern_region ()

void                pattern_region                      (PixelRegion *dest,
                                                         PixelRegion *mask,
                                                         TempBuf *pattern,
                                                         gint off_x,
                                                         gint off_y);

dest :

mask :

pattern :

off_x :

off_y :


blend_region ()

void                blend_region                        (PixelRegion *src1,
                                                         PixelRegion *src2,
                                                         PixelRegion *dest,
                                                         guchar blend);

src1 :

src2 :

dest :

blend :


shade_region ()

void                shade_region                        (PixelRegion *src,
                                                         PixelRegion *dest,
                                                         guchar *color,
                                                         guchar blend);

src :

dest :

color :

blend :


copy_region ()

void                copy_region                         (PixelRegion *src,
                                                         PixelRegion *dest);