procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-04 09:53:25 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions
gimp/app/operations/layer-modes/gimp-layer-modes.c

1517 lines
55 KiB
C
Raw Normal View History

app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* gimp-layer-modes.c
* Copyright (C) 2017 Michael Natterer <mitch@gimp.org>
* Øyvind Kolås <pippin@gimp.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
Change the license URL from http://www.gnu.org/licenses/ to https://
2018-07-11 23:27:07 +02:00
* along with this program. If not, see <https://www.gnu.org/licenses/>.
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
*/
#include "config.h"
#include <glib-object.h>
app: improve gimp_layer_mode_get_format() When the layer mode is composite-space agnostic, return a fast format based on the preferred format's model, not the exact format.
2018-02-12 13:32:59 -05:00
#include <gegl.h>
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
#include "../operations-types.h"
app: improve gimp_layer_mode_get_format() When the layer mode is composite-space agnostic, return a fast format based on the preferred format's model, not the exact format.
2018-02-12 13:32:59 -05:00
#include "gegl/gimp-babl.h"
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
#include "gimpoperationlayermode.h"
#include "gimpoperationlayermode-blend.h"
app: merge the GimpLayerModeFunc into gimp-layer-modes.c's array and remove gimplayermodefunctions.[ch]. Make gimp_operation_normal_process() a normal function and redirect to SSE internally.
2017-02-15 02:25:44 +01:00
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
#include "gimp-layer-modes.h"
app: make struct GimpLayerModeInfo private
2017-02-05 16:06:53 +01:00
typedef struct _GimpLayerModeInfo GimpLayerModeInfo;
struct _GimpLayerModeInfo
{
app: move bottom-layer special casing to GimpOperationLayerMode GimpFilter's is_last_node field only reflects the item's position within the parent stack. When a layer is contained in a pass- through group, it can be the last layer of the group, while not being the last layer in the graph as a whole (paticularly, if there are visible layers below the group). In fact, when we have nested pass-through groups, whether or not a layer is the last node depends on which group we're considering as the root (since we exclude the backdrop from the group's projection, resulting in different graphs for different groups). Instead of rolling our own graph traversal, just move the relevant logic to GimpOperationLayerMode, and let GEGL do the work for us. At processing time, we can tell if we're the last node by checking if we have any input. For this to work, GimpOperationLayerMode's process() function needs to have control over what's going on. Replace the derived op classes, which override process(), with a call to the layer mode's function (as per gimp_layer_mode_get_function()) in GimpOperationLayerMode's process() function. (Well, actually, this commit keeps the ops around, and just hacks around them in gimp_layer_mode_get_operation(), because laziness :P) Keep using the layer's is_last_node property to do the invalidation.
2017-04-21 19:42:04 -04:00
GimpLayerMode layer_mode;
const gchar *op_name;
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
GimpLayerModeBlendFunc blend_function;
app: move bottom-layer special casing to GimpOperationLayerMode GimpFilter's is_last_node field only reflects the item's position within the parent stack. When a layer is contained in a pass- through group, it can be the last layer of the group, while not being the last layer in the graph as a whole (paticularly, if there are visible layers below the group). In fact, when we have nested pass-through groups, whether or not a layer is the last node depends on which group we're considering as the root (since we exclude the backdrop from the group's projection, resulting in different graphs for different groups). Instead of rolling our own graph traversal, just move the relevant logic to GimpOperationLayerMode, and let GEGL do the work for us. At processing time, we can tell if we're the last node by checking if we have any input. For this to work, GimpOperationLayerMode's process() function needs to have control over what's going on. Replace the derived op classes, which override process(), with a call to the layer mode's function (as per gimp_layer_mode_get_function()) in GimpOperationLayerMode's process() function. (Well, actually, this commit keeps the ops around, and just hacks around them in gimp_layer_mode_get_operation(), because laziness :P) Keep using the layer's is_last_node property to do the invalidation.
2017-04-21 19:42:04 -04:00
GimpLayerModeFlags flags;
GimpLayerModeContext context;
GimpLayerCompositeMode paint_composite_mode;
GimpLayerCompositeMode composite_mode;
GimpLayerColorSpace composite_space;
GimpLayerColorSpace blend_space;
app: make struct GimpLayerModeInfo private
2017-02-05 16:06:53 +01:00
};
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
/* static variables */
app: merge the GimpLayerModeFunc into gimp-layer-modes.c's array and remove gimplayermodefunctions.[ch]. Make gimp_operation_normal_process() a normal function and redirect to SSE internally.
2017-02-15 02:25:44 +01:00
static const GimpLayerModeInfo layer_mode_infos[] =
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
{
*: rename NORMAL to NORMAL_LEGACY and NORMAL_LINEAR to NORMAL and make NORMAL_LEGACY immutable.
2017-02-26 16:26:34 +01:00
{ GIMP_LAYER_MODE_NORMAL_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:normal",
app: add LEGACY flag to NORMAL_LEGACY mode Not that we use that for anything...
2017-03-08 13:16:37 -05:00
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
*: rename NORMAL to NORMAL_LEGACY and NORMAL_LINEAR to NORMAL and make NORMAL_LEGACY immutable.
2017-02-26 16:26:34 +01:00
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
app: add gimp_layer_mode_is_trivial() Add a TRIVIAL layer-mode flag, and corresponding gimp_layer_mode_is_trivial() function, which indicates if the blend function of a given layer mode is trivial, i.e., either never modifies the source pixels (for non-subtractive modes), or always clears the destination pixels (for subtractive modes).
2018-12-02 02:55:05 -05:00
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_TRIVIAL,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_UNION,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_DISSOLVE,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:dissolve",
app: add gimp_layer_mode_is_trivial() Add a TRIVIAL layer-mode flag, and corresponding gimp_layer_mode_is_trivial() function, which indicates if the blend function of a given layer mode is trivial, i.e., either never modifies the source pixels (for non-subtractive modes), or always clears the destination pixels (for subtractive modes).
2018-12-02 02:55:05 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_TRIVIAL,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_UNION
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app, libgimp, plug-ins: remove the _LINEAR layer mode variants Missing: PDB API to set the various sub-modes we now have for layer modes.
2017-02-19 23:14:44 +01:00
{ GIMP_LAYER_MODE_BEHIND_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:behind",
app, libgimp, plug-ins: remove the _LINEAR layer mode variants Missing: PDB API to set the various sub-modes we now have for layer modes.
2017-02-19 23:14:44 +01:00
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: remove "Edit -> Fade..." This commit completely removes the "Edit -> Fade..." feature, because... - The main reason is that "fade" requires us to keep two buffers, instead of one, for each fadeable undo step, doubling (or worse, since the extra buffer might have higher precision than the drawable) the space consumed by these steps. This has notable impact when editing large images. This overhead is incurred even when not actually using "fade", and since it seems to be very rarely used, this is too wasteful. - "Fade" is broken in 2.10: when comitting a filter, we copy the cached parts of the result into the apply buffer. However, the result cache sits after the mode node, while the apply buffer should contain the result of the filter *before* the mode node, which can lead to wrong results in the general case. - The same behavior can be trivially achieved "manually", by duplicating the layer, editing the duplicate, and changing its opacity/mode. - If we really want this feature, now that most filters are GEGL ops, it makes more sense to just add opacity/mode options to the filter tool, instead of having this be a separate step.
2018-12-27 11:16:04 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_PAINT,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_UNION,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_MULTIPLY_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:multiply-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_SCREEN_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:screen-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_OVERLAY_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:softlight-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_DIFFERENCE_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:difference-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_ADDITION_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:addition-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_SUBTRACT_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:subtract-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_DARKEN_ONLY_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:darken-only-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_LIGHTEN_ONLY_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:lighten-only-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_HSV_HUE_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:hsv-hue-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_HSV_SATURATION_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:hsv-saturation-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: rename "Color (HSV) (legacy)" mode to "Color (HSL) (legacy)" The color-space qualification is, in fact, a 2.9 thing, so there's no historic reason to keep the wrong name for the legacy mode.
2017-03-16 06:17:05 -04:00
{ GIMP_LAYER_MODE_HSL_COLOR_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
app: rename "Color (HSV) (legacy)" mode to "Color (HSL) (legacy)" The color-space qualification is, in fact, a 2.9 thing, so there's no historic reason to keep the wrong name for the legacy mode.
2017-03-16 06:17:05 -04:00
.op_name = "gimp:hsl-color-legacy",
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_HSV_VALUE_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:hsv-value-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_DIVIDE_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:divide-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_DODGE_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:dodge-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_BURN_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:burn-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_HARDLIGHT_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:hardlight-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_SOFTLIGHT_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:softlight-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_GRAIN_EXTRACT_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:grain-extract-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_GRAIN_MERGE_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:grain-merge-legacy",
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: implement color-erase mode as a GimpOperationLayerMode blendfun ... and get rid of the dedicated op. This gives us support for all the blend/composite options for this mode. Rename COLOR_ERASE to COLOR_ERASE_LEGACY, with perceptual blending/ compositing and immutable everything, and add a new COLOR_ERASE mode, defaulting to linear blending/compositing, with mutable everything. Modify affected code.
2017-03-08 13:06:46 -05:00
{ GIMP_LAYER_MODE_COLOR_ERASE_LEGACY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
app: implement color-erase mode as a GimpOperationLayerMode blendfun ... and get rid of the dedicated op. This gives us support for all the blend/composite options for this mode. Rename COLOR_ERASE to COLOR_ERASE_LEGACY, with perceptual blending/ compositing and immutable everything, and add a new COLOR_ERASE mode, defaulting to linear blending/compositing, with mutable everything. Modify affected code.
2017-03-08 13:06:46 -05:00
.op_name = "gimp:layer-mode",
app: specify blend function for GIMP_LAYER_MODE_COLOR_ERASE_LEGACY This is what happens when you edit code with sed :P
2017-08-19 15:30:28 -04:00
.blend_function = gimp_operation_layer_mode_blend_color_erase,
app: implement color-erase mode as a GimpOperationLayerMode blendfun ... and get rid of the dedicated op. This gives us support for all the blend/composite options for this mode. Rename COLOR_ERASE to COLOR_ERASE_LEGACY, with perceptual blending/ compositing and immutable everything, and add a new COLOR_ERASE mode, defaulting to linear blending/compositing, with mutable everything. Modify affected code.
2017-03-08 13:06:46 -05:00
.flags = GIMP_LAYER_MODE_FLAG_LEGACY |
GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
app: make blend/composite attributes of color-erase immutable
2017-02-17 18:11:06 -05:00
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
app: add GIMP_LAYER_MODE_FLAG_SUBTRACTIVE Most modes only modify the *color* of overlapping dest/src regions, however, erase and color-erase may also reduce their *alpha*, i.e., eliminate some of the overlapping content. Flag these modes with the new SUBTRACTIVE flag, as they require more general compositing code. The next commit adds the said code.
2017-03-08 06:36:39 -05:00
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_SUBTRACTIVE,
app: remove "Edit -> Fade..." This commit completely removes the "Edit -> Fade..." feature, because... - The main reason is that "fade" requires us to keep two buffers, instead of one, for each fadeable undo step, doubling (or worse, since the extra buffer might have higher precision than the drawable) the space consumed by these steps. This has notable impact when editing large images. This overhead is incurred even when not actually using "fade", and since it seems to be very rarely used, this is too wasteful. - "Fade" is broken in 2.10: when comitting a filter, we copy the cached parts of the result into the apply buffer. However, the result cache sits after the mode node, while the apply buffer should contain the result of the filter *before* the mode node, which can lead to wrong results in the general case. - The same behavior can be trivially achieved "manually", by duplicating the layer, editing the duplicate, and changing its opacity/mode. - If we really want this feature, now that most filters are GEGL ops, it makes more sense to just add opacity/mode options to the filter tool, instead of having this be a separate step.
2018-12-27 11:16:04 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_PAINT,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_OVERLAY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_overlay,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_LCH_HUE,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_lch_hue,
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_LAB
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_LCH_CHROMA,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_lch_chroma,
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_LAB
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_LCH_COLOR,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_lch_color,
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_LAB
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_LCH_LIGHTNESS,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_lch_lightness,
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_LAB
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
*: rename NORMAL to NORMAL_LEGACY and NORMAL_LINEAR to NORMAL and make NORMAL_LEGACY immutable.
2017-02-26 16:26:34 +01:00
{ GIMP_LAYER_MODE_NORMAL,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:normal",
app: add gimp_layer_mode_is_trivial() Add a TRIVIAL layer-mode flag, and corresponding gimp_layer_mode_is_trivial() function, which indicates if the blend function of a given layer mode is trivial, i.e., either never modifies the source pixels (for non-subtractive modes), or always clears the destination pixels (for subtractive modes).
2018-12-02 02:55:05 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_TRIVIAL,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_UNION,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app, libgimp, plug-ins: remove the _LINEAR layer mode variants Missing: PDB API to set the various sub-modes we now have for layer modes.
2017-02-19 23:14:44 +01:00
{ GIMP_LAYER_MODE_BEHIND,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:behind",
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE,
app: remove "Edit -> Fade..." This commit completely removes the "Edit -> Fade..." feature, because... - The main reason is that "fade" requires us to keep two buffers, instead of one, for each fadeable undo step, doubling (or worse, since the extra buffer might have higher precision than the drawable) the space consumed by these steps. This has notable impact when editing large images. This overhead is incurred even when not actually using "fade", and since it seems to be very rarely used, this is too wasteful. - "Fade" is broken in 2.10: when comitting a filter, we copy the cached parts of the result into the apply buffer. However, the result cache sits after the mode node, while the apply buffer should contain the result of the filter *before* the mode node, which can lead to wrong results in the general case. - The same behavior can be trivially achieved "manually", by duplicating the layer, editing the duplicate, and changing its opacity/mode. - If we really want this feature, now that most filters are GEGL ops, it makes more sense to just add opacity/mode options to the filter tool, instead of having this be a separate step.
2018-12-27 11:16:04 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_PAINT,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_UNION,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_MULTIPLY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_multiply,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
app: layer-modes, by default use linear blend_space for add/sub/mul/div
2017-02-20 20:00:37 +01:00
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_SCREEN,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_screen,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_DIFFERENCE,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_difference,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_ADDITION,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_addition,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
app: layer-modes, by default use linear blend_space for add/sub/mul/div
2017-02-20 20:00:37 +01:00
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_SUBTRACT,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_subtract,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
app: layer-modes, by default use linear blend_space for add/sub/mul/div
2017-02-20 20:00:37 +01:00
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_DARKEN_ONLY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_darken_only,
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: layer-modes: add comments to lighten/darken only The lack of a blend space is there for a reason, document it.
2017-02-20 20:12:26 +01:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR
/* no blend_space: reuse composite space, no conversion thus fewer copies */
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_LIGHTEN_ONLY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_lighten_only,
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: layer-modes: add comments to lighten/darken only The lack of a blend space is there for a reason, document it.
2017-02-20 20:12:26 +01:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR
/* no blend_space: reuse composite space, no conversion thus fewer copies */
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_HSV_HUE,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_hsv_hue,
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_HSV_SATURATION,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_hsv_saturation,
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: rename "Color (HSV)" mode to "Color (HSL)" ... since that's the color space it actually works in. Keep the legacy "Color (HSV)" mode's name as is, wrong as it is, since, well, that's what it used to be called...
2017-03-15 19:30:01 -04:00
{ GIMP_LAYER_MODE_HSL_COLOR,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_hsl_color,
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_HSV_VALUE,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_hsv_value,
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_DIVIDE,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_divide,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
app: layer-modes, by default use linear blend_space for add/sub/mul/div
2017-02-20 20:00:37 +01:00
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_DODGE,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_dodge,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_BURN,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_burn,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_HARDLIGHT,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_hardlight,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_SOFTLIGHT,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_softlight,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_GRAIN_EXTRACT,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_grain_extract,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_GRAIN_MERGE,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_grain_merge,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_VIVID_LIGHT,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_vivid_light,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_PIN_LIGHT,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_pin_light,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_LINEAR_LIGHT,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_linear_light,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_HARD_MIX,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_hard_mix,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_EXCLUSION,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_exclusion,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_LINEAR_BURN,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_linear_burn,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_LUMA_DARKEN_ONLY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_luma_darken_only,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_LUMA_LIGHTEN_ONLY,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_luma_lighten_only,
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app, libgimp: commit regenerated files after enum GimpLayerMode change and reorder the GimpLayerModeInfo array correctly.
2017-02-20 18:21:12 +01:00
{ GIMP_LAYER_MODE_LUMINANCE,
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_luminance,
app, libgimp: commit regenerated files after enum GimpLayerMode change and reorder the GimpLayerModeInfo array correctly.
2017-02-20 18:21:12 +01:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE,
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app, libgimp: commit regenerated files after enum GimpLayerMode change and reorder the GimpLayerModeInfo array correctly.
2017-02-20 18:21:12 +01:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR
},
app: implement color-erase mode as a GimpOperationLayerMode blendfun ... and get rid of the dedicated op. This gives us support for all the blend/composite options for this mode. Rename COLOR_ERASE to COLOR_ERASE_LEGACY, with perceptual blending/ compositing and immutable everything, and add a new COLOR_ERASE mode, defaulting to linear blending/compositing, with mutable everything. Modify affected code.
2017-03-08 13:06:46 -05:00
{ GIMP_LAYER_MODE_COLOR_ERASE,
.op_name = "gimp:layer-mode",
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.blend_function = gimp_operation_layer_mode_blend_color_erase,
app: implement color-erase mode as a GimpOperationLayerMode blendfun ... and get rid of the dedicated op. This gives us support for all the blend/composite options for this mode. Rename COLOR_ERASE to COLOR_ERASE_LEGACY, with perceptual blending/ compositing and immutable everything, and add a new COLOR_ERASE mode, defaulting to linear blending/compositing, with mutable everything. Modify affected code.
2017-03-08 13:06:46 -05:00
.flags = GIMP_LAYER_MODE_FLAG_SUBTRACTIVE,
app: make color-erase mode an ordinary layer mode Include color-erase mode in the menu for layers.
2017-03-10 14:41:25 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: implement color-erase mode as a GimpOperationLayerMode blendfun ... and get rid of the dedicated op. This gives us support for all the blend/composite options for this mode. Rename COLOR_ERASE to COLOR_ERASE_LEGACY, with perceptual blending/ compositing and immutable everything, and add a new COLOR_ERASE mode, defaulting to linear blending/compositing, with mutable everything. Modify affected code.
2017-03-08 13:06:46 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR,
.blend_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR
},
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
{ GIMP_LAYER_MODE_ERASE,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:erase",
app: add GIMP_LAYER_MODE_FLAG_SUBTRACTIVE Most modes only modify the *color* of overlapping dest/src regions, however, erase and color-erase may also reduce their *alpha*, i.e., eliminate some of the overlapping content. Flag these modes with the new SUBTRACTIVE flag, as they require more general compositing code. The next commit adds the said code.
2017-03-08 06:36:39 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
app: add gimp_layer_mode_is_alpha_only() ... which determines if a layer mode's blend function only affects the alpha, maintaining the backdrop's color. This is currently true only for ERASE, SPLIT, and ANTI_ERASE modes.
2018-05-07 16:35:42 -04:00
GIMP_LAYER_MODE_FLAG_SUBTRACTIVE |
app: add gimp_layer_mode_is_trivial() Add a TRIVIAL layer-mode flag, and corresponding gimp_layer_mode_is_trivial() function, which indicates if the blend function of a given layer mode is trivial, i.e., either never modifies the source pixels (for non-subtractive modes), or always clears the destination pixels (for subtractive modes).
2018-12-02 02:55:05 -05:00
GIMP_LAYER_MODE_FLAG_ALPHA_ONLY |
GIMP_LAYER_MODE_FLAG_TRIVIAL,
app: make erase mode an ordinary layer/paint mode Include erase mode in the menu for layers and general paint tools. This makes the eraser tool somewhat unnecessary, but allows for interesting use cases (e.g., airbrush eraser, etc.)
2017-03-10 14:35:46 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: add merge layer mode Merge mode lays the source layer on top of the destination, same as normal mode, however, it assumes the source and destination are two parts of an original whole, and are therefore mutually exclusive. This is useful for blending cut & pasted content without artifacts, or for replacing erased content in general.
2017-03-10 17:59:17 -05:00
{ GIMP_LAYER_MODE_MERGE,
.op_name = "gimp:merge",
app: add gimp_layer_mode_is_trivial() Add a TRIVIAL layer-mode flag, and corresponding gimp_layer_mode_is_trivial() function, which indicates if the blend function of a given layer mode is trivial, i.e., either never modifies the source pixels (for non-subtractive modes), or always clears the destination pixels (for subtractive modes).
2018-12-02 02:55:05 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_TRIVIAL,
app: add merge layer mode Merge mode lays the source layer on top of the destination, same as normal mode, however, it assumes the source and destination are two parts of an original whole, and are therefore mutually exclusive. This is useful for blending cut & pasted content without artifacts, or for replacing erased content in general.
2017-03-10 17:59:17 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_UNION,
app: add merge layer mode Merge mode lays the source layer on top of the destination, same as normal mode, however, it assumes the source and destination are two parts of an original whole, and are therefore mutually exclusive. This is useful for blending cut & pasted content without artifacts, or for replacing erased content in general.
2017-03-10 17:59:17 -05:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR
},
app: add split layer mode Subtracts the source layer from the destination, such that recompositing the result with the source using merge mode reproduces the original content.
2017-03-10 18:28:40 -05:00
{ GIMP_LAYER_MODE_SPLIT,
.op_name = "gimp:split",
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
app: add gimp_layer_mode_is_alpha_only() ... which determines if a layer mode's blend function only affects the alpha, maintaining the backdrop's color. This is currently true only for ERASE, SPLIT, and ANTI_ERASE modes.
2018-05-07 16:35:42 -04:00
GIMP_LAYER_MODE_FLAG_SUBTRACTIVE |
app: add gimp_layer_mode_is_trivial() Add a TRIVIAL layer-mode flag, and corresponding gimp_layer_mode_is_trivial() function, which indicates if the blend function of a given layer mode is trivial, i.e., either never modifies the source pixels (for non-subtractive modes), or always clears the destination pixels (for subtractive modes).
2018-12-02 02:55:05 -05:00
GIMP_LAYER_MODE_FLAG_ALPHA_ONLY |
GIMP_LAYER_MODE_FLAG_TRIVIAL,
app: add split layer mode Subtracts the source layer from the destination, such that recompositing the result with the source using merge mode reproduces the original content.
2017-03-10 18:28:40 -05:00
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP,
.composite_mode = GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP
app: add split layer mode Subtracts the source layer from the destination, such that recompositing the result with the source using merge mode reproduces the original content.
2017-03-10 18:28:40 -05:00
},
app: add pass-through layer mode Only add the enum-value/mode-info for now. Pass-through mode appears above normal mode, in the default group, for layer groups only.
2017-04-21 13:38:22 -04:00
{ GIMP_LAYER_MODE_PASS_THROUGH,
app: add dedicated op for pass through mode, with shortcuts Pass through mode uses the same compositing logic as REPLACE mode, however, it's a special case of REPLACE, where the layer is already composited against the backdrop. This allows us to take a few shortcuts that aren't generally applicable to REPLACE mode. Add a dedicated op class for pass through mode, derived from the REPLACE mode op, implementing these shortcuts.
2017-08-31 11:20:37 -04:00
.op_name = "gimp:pass-through",
app: mark REPLACE and PASS_THROUGH modes as trivial
2018-12-03 09:51:15 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_TRIVIAL,
app: add pass-through layer mode Only add the enum-value/mode-info for now. Pass-through mode appears above normal mode, in the default group, for layer groups only.
2017-04-21 13:38:22 -04:00
.context = GIMP_LAYER_MODE_CONTEXT_GROUP,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.composite_mode = GIMP_LAYER_COMPOSITE_UNION,
app: add pass-through layer mode Only add the enum-value/mode-info for now. Pass-through mode appears above normal mode, in the default group, for layer groups only.
2017-04-21 13:38:22 -04:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR
},
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
{ GIMP_LAYER_MODE_REPLACE,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:replace",
app: mark REPLACE and PASS_THROUGH modes as trivial
2018-12-03 09:51:15 -05:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_TRIVIAL,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_UNION,
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
.composite_space = GIMP_LAYER_COLOR_SPACE_RGB_LINEAR
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
{ GIMP_LAYER_MODE_ANTI_ERASE,
app: more layer mode info Make the layer mode arrays more readable, and fill in more fields, even for modes that don't use them yet. Fix a few existing entries.
2017-02-16 20:25:57 -05:00
.op_name = "gimp:anti-erase",
app: add gimp_layer_mode_is_alpha_only() ... which determines if a layer mode's blend function only affects the alpha, maintaining the backdrop's color. This is currently true only for ERASE, SPLIT, and ANTI_ERASE modes.
2018-05-07 16:35:42 -04:00
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_ALPHA_ONLY,
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
.paint_composite_mode = GIMP_LAYER_COMPOSITE_UNION,
.composite_mode = GIMP_LAYER_COMPOSITE_UNION
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
}
};
static const GimpLayerMode layer_mode_group_default[] =
{
app: add pass-through layer mode Only add the enum-value/mode-info for now. Pass-through mode appears above normal mode, in the default group, for layer groups only.
2017-04-21 13:38:22 -04:00
GIMP_LAYER_MODE_PASS_THROUGH,
GIMP_LAYER_MODE_SEPARATOR,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_NORMAL,
app: derive the layer-mode menu layout entirely from the info arrays Replace the 'with-behind' and 'with-replace' properties with a single 'context' property, and use it to select the included layer modes, according to their context mask. Add a dummy GIMP_LAYER_MODE_SEPARATOR value to the GimpLayerMode enum, and use it to explicitly mark the menu separators in the layer-mode group arrays; add separators to the layer-mode menu accordingly. Update the rest of the code to use 'context' instead of 'with-behind' and 'with-replace'. In particular, in the layers and layer options dialogs, select the right context based on whether or not the selected layer is a group.
2017-02-17 05:20:53 -05:00
GIMP_LAYER_MODE_REPLACE,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_DISSOLVE,
app: derive the layer-mode menu layout entirely from the info arrays Replace the 'with-behind' and 'with-replace' properties with a single 'context' property, and use it to select the included layer modes, according to their context mask. Add a dummy GIMP_LAYER_MODE_SEPARATOR value to the GimpLayerMode enum, and use it to explicitly mark the menu separators in the layer-mode group arrays; add separators to the layer-mode menu accordingly. Update the rest of the code to use 'context' instead of 'with-behind' and 'with-replace'. In particular, in the layers and layer options dialogs, select the right context based on whether or not the selected layer is a group.
2017-02-17 05:20:53 -05:00
GIMP_LAYER_MODE_BEHIND,
GIMP_LAYER_MODE_COLOR_ERASE,
GIMP_LAYER_MODE_ERASE,
GIMP_LAYER_MODE_ANTI_ERASE,
app: add merge layer mode Merge mode lays the source layer on top of the destination, same as normal mode, however, it assumes the source and destination are two parts of an original whole, and are therefore mutually exclusive. This is useful for blending cut & pasted content without artifacts, or for replacing erased content in general.
2017-03-10 17:59:17 -05:00
GIMP_LAYER_MODE_MERGE,
app: add split layer mode Subtracts the source layer from the destination, such that recompositing the result with the source using merge mode reproduces the original content.
2017-03-10 18:28:40 -05:00
GIMP_LAYER_MODE_SPLIT,
app: derive the layer-mode menu layout entirely from the info arrays Replace the 'with-behind' and 'with-replace' properties with a single 'context' property, and use it to select the included layer modes, according to their context mask. Add a dummy GIMP_LAYER_MODE_SEPARATOR value to the GimpLayerMode enum, and use it to explicitly mark the menu separators in the layer-mode group arrays; add separators to the layer-mode menu accordingly. Update the rest of the code to use 'context' instead of 'with-behind' and 'with-replace'. In particular, in the layers and layer options dialogs, select the right context based on whether or not the selected layer is a group.
2017-02-17 05:20:53 -05:00
GIMP_LAYER_MODE_SEPARATOR,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_LIGHTEN_ONLY,
GIMP_LAYER_MODE_LUMA_LIGHTEN_ONLY,
GIMP_LAYER_MODE_SCREEN,
GIMP_LAYER_MODE_DODGE,
GIMP_LAYER_MODE_ADDITION,
app: derive the layer-mode menu layout entirely from the info arrays Replace the 'with-behind' and 'with-replace' properties with a single 'context' property, and use it to select the included layer modes, according to their context mask. Add a dummy GIMP_LAYER_MODE_SEPARATOR value to the GimpLayerMode enum, and use it to explicitly mark the menu separators in the layer-mode group arrays; add separators to the layer-mode menu accordingly. Update the rest of the code to use 'context' instead of 'with-behind' and 'with-replace'. In particular, in the layers and layer options dialogs, select the right context based on whether or not the selected layer is a group.
2017-02-17 05:20:53 -05:00
GIMP_LAYER_MODE_SEPARATOR,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_DARKEN_ONLY,
GIMP_LAYER_MODE_LUMA_DARKEN_ONLY,
GIMP_LAYER_MODE_MULTIPLY,
GIMP_LAYER_MODE_BURN,
app: move exclusion and linear-burn modes to a more logical position ... in the layer-mode menu (this only affects UI.)
2018-04-26 16:06:08 -04:00
GIMP_LAYER_MODE_LINEAR_BURN,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
app: derive the layer-mode menu layout entirely from the info arrays Replace the 'with-behind' and 'with-replace' properties with a single 'context' property, and use it to select the included layer modes, according to their context mask. Add a dummy GIMP_LAYER_MODE_SEPARATOR value to the GimpLayerMode enum, and use it to explicitly mark the menu separators in the layer-mode group arrays; add separators to the layer-mode menu accordingly. Update the rest of the code to use 'context' instead of 'with-behind' and 'with-replace'. In particular, in the layers and layer options dialogs, select the right context based on whether or not the selected layer is a group.
2017-02-17 05:20:53 -05:00
GIMP_LAYER_MODE_SEPARATOR,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_OVERLAY,
GIMP_LAYER_MODE_SOFTLIGHT,
GIMP_LAYER_MODE_HARDLIGHT,
GIMP_LAYER_MODE_VIVID_LIGHT,
GIMP_LAYER_MODE_PIN_LIGHT,
GIMP_LAYER_MODE_LINEAR_LIGHT,
GIMP_LAYER_MODE_HARD_MIX,
app: derive the layer-mode menu layout entirely from the info arrays Replace the 'with-behind' and 'with-replace' properties with a single 'context' property, and use it to select the included layer modes, according to their context mask. Add a dummy GIMP_LAYER_MODE_SEPARATOR value to the GimpLayerMode enum, and use it to explicitly mark the menu separators in the layer-mode group arrays; add separators to the layer-mode menu accordingly. Update the rest of the code to use 'context' instead of 'with-behind' and 'with-replace'. In particular, in the layers and layer options dialogs, select the right context based on whether or not the selected layer is a group.
2017-02-17 05:20:53 -05:00
GIMP_LAYER_MODE_SEPARATOR,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_DIFFERENCE,
app: move exclusion and linear-burn modes to a more logical position ... in the layer-mode menu (this only affects UI.)
2018-04-26 16:06:08 -04:00
GIMP_LAYER_MODE_EXCLUSION,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_SUBTRACT,
GIMP_LAYER_MODE_GRAIN_EXTRACT,
GIMP_LAYER_MODE_GRAIN_MERGE,
GIMP_LAYER_MODE_DIVIDE,
app: derive the layer-mode menu layout entirely from the info arrays Replace the 'with-behind' and 'with-replace' properties with a single 'context' property, and use it to select the included layer modes, according to their context mask. Add a dummy GIMP_LAYER_MODE_SEPARATOR value to the GimpLayerMode enum, and use it to explicitly mark the menu separators in the layer-mode group arrays; add separators to the layer-mode menu accordingly. Update the rest of the code to use 'context' instead of 'with-behind' and 'with-replace'. In particular, in the layers and layer options dialogs, select the right context based on whether or not the selected layer is a group.
2017-02-17 05:20:53 -05:00
GIMP_LAYER_MODE_SEPARATOR,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_HSV_HUE,
GIMP_LAYER_MODE_HSV_SATURATION,
app: rename "Color (HSV)" mode to "Color (HSL)" ... since that's the color space it actually works in. Keep the legacy "Color (HSV)" mode's name as is, wrong as it is, since, well, that's what it used to be called...
2017-03-15 19:30:01 -04:00
GIMP_LAYER_MODE_HSL_COLOR,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_HSV_VALUE,
app: derive the layer-mode menu layout entirely from the info arrays Replace the 'with-behind' and 'with-replace' properties with a single 'context' property, and use it to select the included layer modes, according to their context mask. Add a dummy GIMP_LAYER_MODE_SEPARATOR value to the GimpLayerMode enum, and use it to explicitly mark the menu separators in the layer-mode group arrays; add separators to the layer-mode menu accordingly. Update the rest of the code to use 'context' instead of 'with-behind' and 'with-replace'. In particular, in the layers and layer options dialogs, select the right context based on whether or not the selected layer is a group.
2017-02-17 05:20:53 -05:00
GIMP_LAYER_MODE_SEPARATOR,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_LCH_HUE,
GIMP_LAYER_MODE_LCH_CHROMA,
GIMP_LAYER_MODE_LCH_COLOR,
GIMP_LAYER_MODE_LCH_LIGHTNESS,
app: move exclusion and linear-burn modes to a more logical position ... in the layer-mode menu (this only affects UI.)
2018-04-26 16:06:08 -04:00
GIMP_LAYER_MODE_LUMINANCE
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
};
static const GimpLayerMode layer_mode_group_legacy[] =
{
*: rename NORMAL to NORMAL_LEGACY and NORMAL_LINEAR to NORMAL and make NORMAL_LEGACY immutable.
2017-02-26 16:26:34 +01:00
GIMP_LAYER_MODE_NORMAL_LEGACY,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_DISSOLVE,
app, libgimp, plug-ins: remove the _LINEAR layer mode variants Missing: PDB API to set the various sub-modes we now have for layer modes.
2017-02-19 23:14:44 +01:00
GIMP_LAYER_MODE_BEHIND_LEGACY,
app: implement color-erase mode as a GimpOperationLayerMode blendfun ... and get rid of the dedicated op. This gives us support for all the blend/composite options for this mode. Rename COLOR_ERASE to COLOR_ERASE_LEGACY, with perceptual blending/ compositing and immutable everything, and add a new COLOR_ERASE mode, defaulting to linear blending/compositing, with mutable everything. Modify affected code.
2017-03-08 13:06:46 -05:00
GIMP_LAYER_MODE_COLOR_ERASE_LEGACY,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
app: derive the layer-mode menu layout entirely from the info arrays Replace the 'with-behind' and 'with-replace' properties with a single 'context' property, and use it to select the included layer modes, according to their context mask. Add a dummy GIMP_LAYER_MODE_SEPARATOR value to the GimpLayerMode enum, and use it to explicitly mark the menu separators in the layer-mode group arrays; add separators to the layer-mode menu accordingly. Update the rest of the code to use 'context' instead of 'with-behind' and 'with-replace'. In particular, in the layers and layer options dialogs, select the right context based on whether or not the selected layer is a group.
2017-02-17 05:20:53 -05:00
GIMP_LAYER_MODE_SEPARATOR,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_LIGHTEN_ONLY_LEGACY,
GIMP_LAYER_MODE_SCREEN_LEGACY,
GIMP_LAYER_MODE_DODGE_LEGACY,
GIMP_LAYER_MODE_ADDITION_LEGACY,
app: derive the layer-mode menu layout entirely from the info arrays Replace the 'with-behind' and 'with-replace' properties with a single 'context' property, and use it to select the included layer modes, according to their context mask. Add a dummy GIMP_LAYER_MODE_SEPARATOR value to the GimpLayerMode enum, and use it to explicitly mark the menu separators in the layer-mode group arrays; add separators to the layer-mode menu accordingly. Update the rest of the code to use 'context' instead of 'with-behind' and 'with-replace'. In particular, in the layers and layer options dialogs, select the right context based on whether or not the selected layer is a group.
2017-02-17 05:20:53 -05:00
GIMP_LAYER_MODE_SEPARATOR,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_DARKEN_ONLY_LEGACY,
GIMP_LAYER_MODE_MULTIPLY_LEGACY,
GIMP_LAYER_MODE_BURN_LEGACY,
app: derive the layer-mode menu layout entirely from the info arrays Replace the 'with-behind' and 'with-replace' properties with a single 'context' property, and use it to select the included layer modes, according to their context mask. Add a dummy GIMP_LAYER_MODE_SEPARATOR value to the GimpLayerMode enum, and use it to explicitly mark the menu separators in the layer-mode group arrays; add separators to the layer-mode menu accordingly. Update the rest of the code to use 'context' instead of 'with-behind' and 'with-replace'. In particular, in the layers and layer options dialogs, select the right context based on whether or not the selected layer is a group.
2017-02-17 05:20:53 -05:00
GIMP_LAYER_MODE_SEPARATOR,
app: show overlay mode also in legacy mode menu The mode group switching combo box is hard to discover, until we use the default group instead of legacy group as default - it is better to make legacy resemble the full old set to.
2017-03-08 18:08:36 +01:00
GIMP_LAYER_MODE_OVERLAY,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_SOFTLIGHT_LEGACY,
GIMP_LAYER_MODE_HARDLIGHT_LEGACY,
app: derive the layer-mode menu layout entirely from the info arrays Replace the 'with-behind' and 'with-replace' properties with a single 'context' property, and use it to select the included layer modes, according to their context mask. Add a dummy GIMP_LAYER_MODE_SEPARATOR value to the GimpLayerMode enum, and use it to explicitly mark the menu separators in the layer-mode group arrays; add separators to the layer-mode menu accordingly. Update the rest of the code to use 'context' instead of 'with-behind' and 'with-replace'. In particular, in the layers and layer options dialogs, select the right context based on whether or not the selected layer is a group.
2017-02-17 05:20:53 -05:00
GIMP_LAYER_MODE_SEPARATOR,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_DIFFERENCE_LEGACY,
GIMP_LAYER_MODE_SUBTRACT_LEGACY,
GIMP_LAYER_MODE_GRAIN_EXTRACT_LEGACY,
GIMP_LAYER_MODE_GRAIN_MERGE_LEGACY,
GIMP_LAYER_MODE_DIVIDE_LEGACY,
app: derive the layer-mode menu layout entirely from the info arrays Replace the 'with-behind' and 'with-replace' properties with a single 'context' property, and use it to select the included layer modes, according to their context mask. Add a dummy GIMP_LAYER_MODE_SEPARATOR value to the GimpLayerMode enum, and use it to explicitly mark the menu separators in the layer-mode group arrays; add separators to the layer-mode menu accordingly. Update the rest of the code to use 'context' instead of 'with-behind' and 'with-replace'. In particular, in the layers and layer options dialogs, select the right context based on whether or not the selected layer is a group.
2017-02-17 05:20:53 -05:00
GIMP_LAYER_MODE_SEPARATOR,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_HSV_HUE_LEGACY,
GIMP_LAYER_MODE_HSV_SATURATION_LEGACY,
app: rename "Color (HSV) (legacy)" mode to "Color (HSL) (legacy)" The color-space qualification is, in fact, a 2.9 thing, so there's no historic reason to keep the wrong name for the legacy mode.
2017-03-16 06:17:05 -04:00
GIMP_LAYER_MODE_HSL_COLOR_LEGACY,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GIMP_LAYER_MODE_HSV_VALUE_LEGACY
};
app, libgimp, plug-ins: remove the _LINEAR layer mode variants Missing: PDB API to set the various sub-modes we now have for layer modes.
2017-02-19 23:14:44 +01:00
static const GimpLayerMode layer_mode_groups[][2] =
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
{
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_NORMAL,
*: rename NORMAL to NORMAL_LEGACY and NORMAL_LINEAR to NORMAL and make NORMAL_LEGACY immutable.
2017-02-26 16:26:34 +01:00
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_NORMAL_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_DISSOLVE,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_DISSOLVE
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_BEHIND,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_BEHIND_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_MULTIPLY,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_MULTIPLY_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_SCREEN,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_SCREEN_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_OVERLAY,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_DIFFERENCE,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_DIFFERENCE_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_ADDITION,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_ADDITION_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_SUBTRACT,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_SUBTRACT_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_DARKEN_ONLY,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_DARKEN_ONLY_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_LIGHTEN_ONLY,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_LIGHTEN_ONLY_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_HSV_HUE,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_HSV_HUE_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_HSV_SATURATION,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_HSV_SATURATION_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: rename "Color (HSV)" mode to "Color (HSL)" ... since that's the color space it actually works in. Keep the legacy "Color (HSV)" mode's name as is, wrong as it is, since, well, that's what it used to be called...
2017-03-15 19:30:01 -04:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_HSL_COLOR,
app: rename "Color (HSV) (legacy)" mode to "Color (HSL) (legacy)" The color-space qualification is, in fact, a 2.9 thing, so there's no historic reason to keep the wrong name for the legacy mode.
2017-03-16 06:17:05 -04:00
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_HSL_COLOR_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_HSV_VALUE,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_HSV_VALUE_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_DIVIDE,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_DIVIDE_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_DODGE,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_DODGE_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_BURN,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_BURN_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_HARDLIGHT,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_HARDLIGHT_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_SOFTLIGHT,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_SOFTLIGHT_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_GRAIN_EXTRACT,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_GRAIN_EXTRACT_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_GRAIN_MERGE,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_GRAIN_MERGE_LEGACY
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_COLOR_ERASE,
app: implement color-erase mode as a GimpOperationLayerMode blendfun ... and get rid of the dedicated op. This gives us support for all the blend/composite options for this mode. Rename COLOR_ERASE to COLOR_ERASE_LEGACY, with perceptual blending/ compositing and immutable everything, and add a new COLOR_ERASE mode, defaulting to linear blending/compositing, with mutable everything. Modify affected code.
2017-03-08 13:06:46 -05:00
[GIMP_LAYER_MODE_GROUP_LEGACY ] = GIMP_LAYER_MODE_COLOR_ERASE_LEGACY,
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_VIVID_LIGHT,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_PIN_LIGHT,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_LINEAR_LIGHT,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_HARD_MIX,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_EXCLUSION,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_LINEAR_BURN,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_LUMA_DARKEN_ONLY,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_LUMA_LIGHTEN_ONLY,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_LUMINANCE,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
app: add luminance mode to the groups array
2017-02-20 13:36:00 -05:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_ERASE,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: add merge layer mode Merge mode lays the source layer on top of the destination, same as normal mode, however, it assumes the source and destination are two parts of an original whole, and are therefore mutually exclusive. This is useful for blending cut & pasted content without artifacts, or for replacing erased content in general.
2017-03-10 17:59:17 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_MERGE,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
},
app: add split layer mode Subtracts the source layer from the destination, such that recompositing the result with the source using merge mode reproduces the original content.
2017-03-10 18:28:40 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_SPLIT,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
},
app: add pass-through layer mode Only add the enum-value/mode-info for now. Pass-through mode appears above normal mode, in the default group, for layer groups only.
2017-04-21 13:38:22 -04:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_PASS_THROUGH,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1,
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_REPLACE,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
},
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{ [GIMP_LAYER_MODE_GROUP_DEFAULT] = GIMP_LAYER_MODE_ANTI_ERASE,
[GIMP_LAYER_MODE_GROUP_LEGACY ] = -1
app: some cleanup and adding const in gimp-layer-modes.c
2017-02-05 16:30:54 +01:00
}
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
};
/* public functions */
void
gimp_layer_modes_init (void)
{
gint i;
for (i = 0; i < G_N_ELEMENTS (layer_mode_infos); i++)
{
app: replace all g_assert() by the newly added gimp_assert() which is just a #define to g_assert for now, but can now easily be turned into something that does some nicer debugging using our new stack trace infrastructure. This commit also reverts all constructed() functions to use assert again.
2018-02-11 22:23:10 +01:00
gimp_assert ((GimpLayerMode) i == layer_mode_infos[i].layer_mode);
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
}
}
app: make struct GimpLayerModeInfo private
2017-02-05 16:06:53 +01:00
static const GimpLayerModeInfo *
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
gimp_layer_mode_info (GimpLayerMode mode)
{
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
g_return_val_if_fail (mode >= 0 && mode < G_N_ELEMENTS (layer_mode_infos),
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
&layer_mode_infos[0]);
return &layer_mode_infos[mode];
}
gboolean
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
gimp_layer_mode_is_legacy (GimpLayerMode mode)
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
{
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
if (! info)
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
return FALSE;
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
return (info->flags & GIMP_LAYER_MODE_FLAG_LEGACY) != 0;
}
app: add layer mode flags to mark blend and compositing modes immutable set all legacy modes to completely immutable and the LAB modes' blend mode to immutable. Change GimpLayer setters and the UI accordingly. Remove the LAB color spaces from the GUI, they can only be used with the LAB blend modes anyway and not changed.
2017-02-13 22:12:39 +01:00
gboolean
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
gimp_layer_mode_is_blend_space_mutable (GimpLayerMode mode)
app: add layer mode flags to mark blend and compositing modes immutable set all legacy modes to completely immutable and the LAB modes' blend mode to immutable. Change GimpLayer setters and the UI accordingly. Remove the LAB color spaces from the GUI, they can only be used with the LAB blend modes anyway and not changed.
2017-02-13 22:12:39 +01:00
{
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
if (! info)
app: add layer mode flags to mark blend and compositing modes immutable set all legacy modes to completely immutable and the LAB modes' blend mode to immutable. Change GimpLayer setters and the UI accordingly. Remove the LAB color spaces from the GUI, they can only be used with the LAB blend modes anyway and not changed.
2017-02-13 22:12:39 +01:00
return FALSE;
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
app: add layer mode flags to mark blend and compositing modes immutable set all legacy modes to completely immutable and the LAB modes' blend mode to immutable. Change GimpLayer setters and the UI accordingly. Remove the LAB color spaces from the GUI, they can only be used with the LAB blend modes anyway and not changed.
2017-02-13 22:12:39 +01:00
return (info->flags & GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE) == 0;
}
gboolean
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
gimp_layer_mode_is_composite_space_mutable (GimpLayerMode mode)
app: add layer mode flags to mark blend and compositing modes immutable set all legacy modes to completely immutable and the LAB modes' blend mode to immutable. Change GimpLayer setters and the UI accordingly. Remove the LAB color spaces from the GUI, they can only be used with the LAB blend modes anyway and not changed.
2017-02-13 22:12:39 +01:00
{
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
if (! info)
app: add layer mode flags to mark blend and compositing modes immutable set all legacy modes to completely immutable and the LAB modes' blend mode to immutable. Change GimpLayer setters and the UI accordingly. Remove the LAB color spaces from the GUI, they can only be used with the LAB blend modes anyway and not changed.
2017-02-13 22:12:39 +01:00
return FALSE;
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
app: add layer mode flags to mark blend and compositing modes immutable set all legacy modes to completely immutable and the LAB modes' blend mode to immutable. Change GimpLayer setters and the UI accordingly. Remove the LAB color spaces from the GUI, they can only be used with the LAB blend modes anyway and not changed.
2017-02-13 22:12:39 +01:00
return (info->flags & GIMP_LAYER_MODE_FLAG_COMPOSITE_SPACE_IMMUTABLE) == 0;
}
gboolean
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
gimp_layer_mode_is_composite_mode_mutable (GimpLayerMode mode)
app: add layer mode flags to mark blend and compositing modes immutable set all legacy modes to completely immutable and the LAB modes' blend mode to immutable. Change GimpLayer setters and the UI accordingly. Remove the LAB color spaces from the GUI, they can only be used with the LAB blend modes anyway and not changed.
2017-02-13 22:12:39 +01:00
{
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
if (! info)
app: add layer mode flags to mark blend and compositing modes immutable set all legacy modes to completely immutable and the LAB modes' blend mode to immutable. Change GimpLayer setters and the UI accordingly. Remove the LAB color spaces from the GUI, they can only be used with the LAB blend modes anyway and not changed.
2017-02-13 22:12:39 +01:00
return FALSE;
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
app: add layer mode flags to mark blend and compositing modes immutable set all legacy modes to completely immutable and the LAB modes' blend mode to immutable. Change GimpLayer setters and the UI accordingly. Remove the LAB color spaces from the GUI, they can only be used with the LAB blend modes anyway and not changed.
2017-02-13 22:12:39 +01:00
return (info->flags & GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE) == 0;
}
app: add GIMP_LAYER_MODE_FLAG_SUBTRACTIVE Most modes only modify the *color* of overlapping dest/src regions, however, erase and color-erase may also reduce their *alpha*, i.e., eliminate some of the overlapping content. Flag these modes with the new SUBTRACTIVE flag, as they require more general compositing code. The next commit adds the said code.
2017-03-08 06:36:39 -05:00
gboolean
gimp_layer_mode_is_subtractive (GimpLayerMode mode)
{
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
if (! info)
return FALSE;
return (info->flags & GIMP_LAYER_MODE_FLAG_SUBTRACTIVE) != 0;
}
app: add gimp_layer_mode_is_alpha_only() ... which determines if a layer mode's blend function only affects the alpha, maintaining the backdrop's color. This is currently true only for ERASE, SPLIT, and ANTI_ERASE modes.
2018-05-07 16:35:42 -04:00
gboolean
gimp_layer_mode_is_alpha_only (GimpLayerMode mode)
{
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
if (! info)
return FALSE;
return (info->flags & GIMP_LAYER_MODE_FLAG_ALPHA_ONLY) != 0;
}
app: add gimp_layer_mode_is_trivial() Add a TRIVIAL layer-mode flag, and corresponding gimp_layer_mode_is_trivial() function, which indicates if the blend function of a given layer mode is trivial, i.e., either never modifies the source pixels (for non-subtractive modes), or always clears the destination pixels (for subtractive modes).
2018-12-02 02:55:05 -05:00
gboolean
gimp_layer_mode_is_trivial (GimpLayerMode mode)
{
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
if (! info)
return FALSE;
return (info->flags & GIMP_LAYER_MODE_FLAG_TRIVIAL) != 0;
}
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
GimpLayerColorSpace
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
gimp_layer_mode_get_blend_space (GimpLayerMode mode)
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
{
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
if (! info)
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
return GIMP_LAYER_COLOR_SPACE_RGB_LINEAR;
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
return info->blend_space;
}
GimpLayerColorSpace
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
gimp_layer_mode_get_composite_space (GimpLayerMode mode)
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
{
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
if (! info)
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
return GIMP_LAYER_COLOR_SPACE_RGB_LINEAR;
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
return info->composite_space;
}
GimpLayerCompositeMode
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
gimp_layer_mode_get_composite_mode (GimpLayerMode mode)
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
{
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
if (! info)
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
return GIMP_LAYER_COMPOSITE_UNION;
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
return info->composite_mode;
}
Bug 778597 - Eraser paints transparent areas with BG color Add a "paint_composite_mode" field to GimpLayerModeInfo and set the mode of the eraser to SRC_ATOP. Defaulting to SRC_OVER for all painting didn't quite do it for all modes.
2017-02-14 22:51:47 +01:00
GimpLayerCompositeMode
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
gimp_layer_mode_get_paint_composite_mode (GimpLayerMode mode)
Bug 778597 - Eraser paints transparent areas with BG color Add a "paint_composite_mode" field to GimpLayerModeInfo and set the mode of the eraser to SRC_ATOP. Defaulting to SRC_OVER for all painting didn't quite do it for all modes.
2017-02-14 22:51:47 +01:00
{
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
if (! info)
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
return GIMP_LAYER_COMPOSITE_UNION;
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
Bug 778597 - Eraser paints transparent areas with BG color Add a "paint_composite_mode" field to GimpLayerModeInfo and set the mode of the eraser to SRC_ATOP. Defaulting to SRC_OVER for all painting didn't quite do it for all modes.
2017-02-14 22:51:47 +01:00
return info->paint_composite_mode;
}
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
const gchar *
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
gimp_layer_mode_get_operation (GimpLayerMode mode)
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
{
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
if (! info)
return "gimp:layer-mode";
return info->op_name;
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
}
app: merge the GimpLayerModeFunc into gimp-layer-modes.c's array and remove gimplayermodefunctions.[ch]. Make gimp_operation_normal_process() a normal function and redirect to SSE internally.
2017-02-15 02:25:44 +01:00
GimpLayerModeFunc
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
gimp_layer_mode_get_function (GimpLayerMode mode)
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
{
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
static GimpLayerModeFunc funcs[G_N_ELEMENTS (layer_mode_infos)];
if (! info)
info = layer_mode_infos;
mode = info - layer_mode_infos;
if (! funcs[mode])
{
GeglNode *node;
GeglOperation *operation;
node = gegl_node_new_child (NULL,
"operation", info->op_name,
NULL);
operation = gegl_node_get_gegl_operation (node);
funcs[mode] = GIMP_OPERATION_LAYER_MODE_GET_CLASS (operation)->process;
g_object_unref (node);
}
return funcs[mode];
}
GimpLayerModeBlendFunc
gimp_layer_mode_get_blend_function (GimpLayerMode mode)
app: merge the GimpLayerModeFunc into gimp-layer-modes.c's array and remove gimplayermodefunctions.[ch]. Make gimp_operation_normal_process() a normal function and redirect to SSE internally.
2017-02-15 02:25:44 +01:00
{
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
if (! info)
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
return NULL;
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
app: layer mode code shuffling Commit 3635cf04ab69bafb76d7583da804f580f2d5fbf3 moved the special handling of bottom-layer compositing to GimpOperationLayerMode. This required giving the op more control over the process() function of its subclasses. As a temporary workaround, the commit bypassed the subclasses entirely, using "gimp:layer-mode" for all modes. This is the reckoning :) Add a process() virtual function to GimpOperationLayerMode, which its subclasses should override instead of GeglOperationPointComposer3's process() functions. Reinstate the subclasses (by returning the correct op in gimp_layer_mode_get_oepration()), and have them override this function. Improve the way gimp_operation_layer_mode_process() dispatches to the actual process function, to slightly lower its overhead and fix some thread-safety issues. Remove the "function" field of the layer-mode info array, and have gimp_layer_mode_get_function() return the GimpOperationLayerMode::process() function of the corresponding op's class (caching the result, to keep it cheap.) This reduces redundancy, allows us to make the ops' process() functions private, and simplifies SSE dispatching (only used by NORMAL mode, currently.) Move the blend and composite functions of the non-specialized layer modes to gimpoperationlayermode-{blend,composite}.[hc], respectively, to improve code organization. Move the SSE2 composite functions to a separate file, so that they can be built as part of libapplayermodes_sse2, allowing libapplayermodes to be built without SSE2 compiler flags. This allows building GIMP with SSE acceleration enabled, while running the resulting binary on a target with no SSE accelration. Add a "blend_function" field to the layer-mode info array, and use it to specify the blend function for the non-specialized modes. This replaces the separate switch() statement that we used previously. Remove the "affected_region" field of the layer-mode info array. We don't need it anymore, since we can go back to using GimpOperationLayerMode's virtual get_affected_region() function. Last but not least, a bunch of code cleanups and consistency adjustments.
2017-08-17 10:26:49 -04:00
return info->blend_function;
app: merge the GimpLayerModeFunc into gimp-layer-modes.c's array and remove gimplayermodefunctions.[ch]. Make gimp_operation_normal_process() a normal function and redirect to SSE internally.
2017-02-15 02:25:44 +01:00
}
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
GimpLayerModeContext
gimp_layer_mode_get_context (GimpLayerMode mode)
{
const GimpLayerModeInfo *info = gimp_layer_mode_info (mode);
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
if (! info)
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
return 0;
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
app: add GimpLayerModeContext enum A bitmask, specifying in which contexts a layer mode is applicable. Can be a combination of: - LAYER: usable as a layer mode for actual layers. - GROUP: usable as a layer mode for layer groups. Currently, all modes that specify LAYER also specify GROUP, and vice versa, but the planned pass-through mode will be GROUP only. - PAINT: can be used as a paint mode. - FADE: can be used for fading. Add a 'context' field to _GimpLayerModeInfo, and provide context masks to all the modes. Use the context mask for validation when setting a layer's mode. The next commit will use the mask when populating the layer mode menus.
2017-02-17 03:49:29 -05:00
return info->context;
}
app: add gimp_layer_mode_get_context_array() which returns an array of modes in the order they would appear in a GimpLayerModeContext's UI (like tool options or the layers dialog), without the separators. Use it in context-commands.c and layers-commands.c instead of static (and outdated) arrays for the actions that cycle through modes.
2017-02-20 23:51:32 +01:00
GimpLayerMode *
gimp_layer_mode_get_context_array (GimpLayerMode mode,
GimpLayerModeContext context,
gint *n_modes)
{
GimpLayerModeGroup group;
const GimpLayerMode *group_modes;
gint n_group_modes;
GimpLayerMode *array;
gint i;
group = gimp_layer_mode_get_group (mode);
group_modes = gimp_layer_mode_get_group_array (group, &n_group_modes);
array = g_new0 (GimpLayerMode, n_group_modes);
*n_modes = 0;
for (i = 0; i < n_group_modes; i++)
{
if (group_modes[i] != GIMP_LAYER_MODE_SEPARATOR &&
(gimp_layer_mode_get_context (group_modes[i]) & context))
{
array[*n_modes] = group_modes[i];
(*n_modes)++;
}
}
return array;
}
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
static gboolean
is_mode_in_array (const GimpLayerMode *modes,
gint n_modes,
GimpLayerMode mode)
{
gint i;
for (i = 0; i < n_modes; i++)
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
{
if (modes[i] == mode)
return TRUE;
}
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
return FALSE;
}
GimpLayerModeGroup
app: whitespace such and such in gimp-layer-modes.c
2017-02-20 14:20:39 -05:00
gimp_layer_mode_get_group (GimpLayerMode mode)
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
{
if (is_mode_in_array (layer_mode_group_default,
G_N_ELEMENTS (layer_mode_group_default), mode))
{
return GIMP_LAYER_MODE_GROUP_DEFAULT;
}
else if (is_mode_in_array (layer_mode_group_legacy,
G_N_ELEMENTS (layer_mode_group_legacy), mode))
{
return GIMP_LAYER_MODE_GROUP_LEGACY;
}
return GIMP_LAYER_MODE_GROUP_DEFAULT;
}
const GimpLayerMode *
gimp_layer_mode_get_group_array (GimpLayerModeGroup group,
gint *n_modes)
{
g_return_val_if_fail (n_modes != NULL, NULL);
switch (group)
{
case GIMP_LAYER_MODE_GROUP_DEFAULT:
*n_modes = G_N_ELEMENTS (layer_mode_group_default);
return layer_mode_group_default;
case GIMP_LAYER_MODE_GROUP_LEGACY:
*n_modes = G_N_ELEMENTS (layer_mode_group_legacy);
return layer_mode_group_legacy;
default:
g_return_val_if_reached (NULL);
}
}
gboolean
gimp_layer_mode_get_for_group (GimpLayerMode old_mode,
GimpLayerModeGroup new_group,
GimpLayerMode *new_mode)
{
gint i;
g_return_val_if_fail (new_mode != NULL, FALSE);
for (i = 0; i < G_N_ELEMENTS (layer_mode_groups); i++)
{
app, libgimp, plug-ins: remove the _LINEAR layer mode variants Missing: PDB API to set the various sub-modes we now have for layer modes.
2017-02-19 23:14:44 +01:00
if (is_mode_in_array (layer_mode_groups[i], 2, old_mode))
app: move layer mode enums and gimp-layer-modes.[ch] to operations/ and to operations/layer-modes/, respectively. Add gimp_layer_modes_init() which asserts on the correct order of the GimpLayerModeInfo array, and switch to accessing the array directly in gimp_layer_mode_info().
2017-02-05 15:59:29 +01:00
{
*new_mode = layer_mode_groups[i][new_group];
if (*new_mode != -1)
return TRUE;
return FALSE;
}
}
*new_mode = -1;
return FALSE;
}
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
const Babl *
app: disregard composite space in non-union alpha-only layer modes In gimp_layer_mode_get_format(), disregard the requested composite space when selecting the format, if the input layer mode is alpha- only, and the requested composite mode is not UNION, since, in this case, the layer mode doesn't combine the layer/backdrop colors, and rather only modifies the alpha of one of them. This allows us to use the preferred format, avoiding gamma conversion. This particularly improves the performance of the Eraser tool in perceptual images.
2019-05-24 01:33:53 -04:00
gimp_layer_mode_get_format (GimpLayerMode mode,
GimpLayerColorSpace blend_space,
GimpLayerColorSpace composite_space,
GimpLayerCompositeMode composite_mode,
const Babl *preferred_format)
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
{
app: disregard composite space in source-only trivial layer modes Extend last commit to also disregard the composite space when the layer mode is trivial and only the source region is included in compositing, since, in this case, the source color is unmodified.
2019-05-24 02:39:15 -04:00
GimpLayerCompositeRegion composite_region;
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
/* for now, all modes perform i/o in the composite space. */
(void) mode;
(void) blend_space;
if (composite_space == GIMP_LAYER_COLOR_SPACE_AUTO)
composite_space = gimp_layer_mode_get_composite_space (mode);
app: disregard composite space in non-union alpha-only layer modes In gimp_layer_mode_get_format(), disregard the requested composite space when selecting the format, if the input layer mode is alpha- only, and the requested composite mode is not UNION, since, in this case, the layer mode doesn't combine the layer/backdrop colors, and rather only modifies the alpha of one of them. This allows us to use the preferred format, avoiding gamma conversion. This particularly improves the performance of the Eraser tool in perceptual images.
2019-05-24 01:33:53 -04:00
if (composite_mode == GIMP_LAYER_COMPOSITE_AUTO)
composite_mode = gimp_layer_mode_get_composite_mode (mode);
app: disregard composite space in source-only trivial layer modes Extend last commit to also disregard the composite space when the layer mode is trivial and only the source region is included in compositing, since, in this case, the source color is unmodified.
2019-05-24 02:39:15 -04:00
composite_region = gimp_layer_mode_get_included_region (mode, composite_mode);
app: disregard composite space in non-union alpha-only layer modes In gimp_layer_mode_get_format(), disregard the requested composite space when selecting the format, if the input layer mode is alpha- only, and the requested composite mode is not UNION, since, in this case, the layer mode doesn't combine the layer/backdrop colors, and rather only modifies the alpha of one of them. This allows us to use the preferred format, avoiding gamma conversion. This particularly improves the performance of the Eraser tool in perceptual images.
2019-05-24 01:33:53 -04:00
if (gimp_layer_mode_is_alpha_only (mode))
{
app: disregard composite space in source-only trivial layer modes Extend last commit to also disregard the composite space when the layer mode is trivial and only the source region is included in compositing, since, in this case, the source color is unmodified.
2019-05-24 02:39:15 -04:00
if (composite_region != GIMP_LAYER_COMPOSITE_REGION_UNION)
app: disregard composite space in non-union alpha-only layer modes In gimp_layer_mode_get_format(), disregard the requested composite space when selecting the format, if the input layer mode is alpha- only, and the requested composite mode is not UNION, since, in this case, the layer mode doesn't combine the layer/backdrop colors, and rather only modifies the alpha of one of them. This allows us to use the preferred format, avoiding gamma conversion. This particularly improves the performance of the Eraser tool in perceptual images.
2019-05-24 01:33:53 -04:00
{
/* alpha-only layer modes don't combine colors in non-union composite
* modes, hence we can disregard the composite space.
*/
composite_space = GIMP_LAYER_COLOR_SPACE_AUTO;
app: disregard composite space in source-only trivial layer modes Extend last commit to also disregard the composite space when the layer mode is trivial and only the source region is included in compositing, since, in this case, the source color is unmodified.
2019-05-24 02:39:15 -04:00
}
}
else if (gimp_layer_mode_is_trivial (mode))
{
if (! (composite_region & GIMP_LAYER_COMPOSITE_REGION_DESTINATION))
{
/* trivial layer modes don't combine colors when only the source
* region is included, hence we can disregard the composite space.
*/
composite_space = GIMP_LAYER_COLOR_SPACE_AUTO;
app: disregard composite space in non-union alpha-only layer modes In gimp_layer_mode_get_format(), disregard the requested composite space when selecting the format, if the input layer mode is alpha- only, and the requested composite mode is not UNION, since, in this case, the layer mode doesn't combine the layer/backdrop colors, and rather only modifies the alpha of one of them. This allows us to use the preferred format, avoiding gamma conversion. This particularly improves the performance of the Eraser tool in perceptual images.
2019-05-24 01:33:53 -04:00
}
}
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
switch (composite_space)
{
case GIMP_LAYER_COLOR_SPACE_AUTO:
app: improve gimp_layer_mode_get_format() When the layer mode is composite-space agnostic, return a fast format based on the preferred format's model, not the exact format.
2018-02-12 13:32:59 -05:00
/* compositing is color-space agnostic. return a format that has a fast
* conversion path to/from the preferred format.
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
*/
Initial space invasion commit in GIMP All babl formats now have a space equivalent to a color profile, determining the format's primaries and TRCs. This commit makes GIMP aware of this. libgimp: - enum GimpPrecision: rename GAMMA values to NON_LINEAR and keep GAMMA as deprecated aliases, add PERCEPTUAL values so we now have LINEAR, NON_LINEAR and PERCPTUAL for each encoding, matching the babl encoding variants RGB, R'G'B' and R~G~B~. - gimp_color_transform_can_gegl_copy() now returns TRUE if both profiles can return a babl space, increasing the amount of fast babl color conversions significantly. - TODO: no solution yet for getting libgimp drawable proxy buffers in the right format with space. plug-ins: - follow the GimpPrecision change. - TODO: everything else unchanged and partly broken or sub-optimal, like setting a new image's color profile too late. app: - add enum GimpTRCType { LINEAR, NON_LINEAR, PERCEPTUAL } as replacement for all "linear" booleans. - change gimp-babl functions to take babl spaces and GimpTRCType parameters and support all sorts of new perceptual ~ formats. - a lot of places changed in the early days of goat invasion didn't take advantage of gimp-babl utility functions and constructed formats manually. They all needed revisiting and many now use much simpler code calling gimp-babl API. - change gimp_babl_format_get_color_profile() to really extract a newly allocated color profile from the format, and add gimp_babl_get_builtin_color_profile() which does the same as gimp_babl_format_get_color_profile() did before. Visited all callers to decide whether they are looking for the format's actual profile, or for one of the builtin profiles, simplifying code that only needs builtin profiles. - drawables have a new get_space_api(), get_linear() is now get_trc(). - images now have a "layer space" and an API to get it, gimp_image_get_layer_format() returns formats in that space. - an image's layer space is created from the image's color profile, change gimpimage-color-profile to deal with that correctly - change many babl_format() calls to babl_format_with_space() and take the space from passed formats or drawables - add function gimp_layer_fix_format_space() which replaces the layer's buffer with one that has the image's layer format, but doesn't change pixel values - use gimp_layer_fix_format_space() to make sure layers loaded from XCF and created by plug-ins have the right space when added to the image, because it's impossible to always assign the right space upon layer creation - "assign color profile" and "discard color profile" now require use of gimp_layer_fix_format_space() too because the profile is now embedded in all formats via the space. Add gimp_image_assign_color_profile() which does all that and call it instead of a simple gimp_image_set_color_profile(), also from the PDB set-color-profile functions, which are essentially "assign" and "discard" calls. - generally, make sure a new image's color profile is set before adding layers to it, gimp_image_set_color_profile() is more than before considered know-what-you-are-doing API. - take special precaution in all places that call gimp_drawable_convert_type(), we now must pass a new_profile from all callers that convert layers within the same image (such as image_convert_type, image_convert_precision), because the layer's new space can't be determined from the image's layer format during the call. - change all "linear" properties to "trc", in all config objects like for levels and curves, in the histogram, in the widgets. This results in some GUI that now has three choices instead of two. TODO: we might want to reduce that back to two later. - keep "linear" boolean properties around as compat if needed for file pasring, but always convert the parsed parsed boolean to GimpTRCType. - TODO: the image's "enable color management" switch is currently broken, will fix that in another commit.
2018-07-21 14:23:01 +02:00
if (! preferred_format ||
gimp_babl_format_get_trc (preferred_format) == GIMP_TRC_LINEAR)
app: propagate space in gimp_layer_mode_get_format We were not propagating the space properly causing compositing and blending to always happen in default/linear sRGB space.
2018-11-01 01:50:13 +01:00
return babl_format_with_space ("RGBA float", preferred_format);
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
else
app: propagate space in gimp_layer_mode_get_format We were not propagating the space properly causing compositing and blending to always happen in default/linear sRGB space.
2018-11-01 01:50:13 +01:00
return babl_format_with_space ("R'G'B'A float", preferred_format);
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
case GIMP_LAYER_COLOR_SPACE_RGB_LINEAR:
app: propagate space in gimp_layer_mode_get_format We were not propagating the space properly causing compositing and blending to always happen in default/linear sRGB space.
2018-11-01 01:50:13 +01:00
return babl_format_with_space ("RGBA float", preferred_format);
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
case GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL:
app: propagate space in gimp_layer_mode_get_format We were not propagating the space properly causing compositing and blending to always happen in default/linear sRGB space.
2018-11-01 01:50:13 +01:00
return babl_format_with_space ("R'G'B'A float", preferred_format);
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
case GIMP_LAYER_COLOR_SPACE_LAB:
app: propagate space in gimp_layer_mode_get_format We were not propagating the space properly causing compositing and blending to always happen in default/linear sRGB space.
2018-11-01 01:50:13 +01:00
return babl_format_with_space ("CIE Lab alpha float", preferred_format);
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
}
app: propagate space in gimp_layer_mode_get_format We were not propagating the space properly causing compositing and blending to always happen in default/linear sRGB space.
2018-11-01 01:50:13 +01:00
g_return_val_if_reached (babl_format_with_space ("RGBA float", preferred_format));
app: remove GIMP_LAYER_MODE_FLAG_WANTS_LINEAR_DATA and friends Instead, add a gimp_layer_mode_get_format() function, which takes the layer mode, composite space, and blend space, and returns the I/O format. Currently, we always use the composite space format as the I/O format. This simplifies gimp_composite_blend(), and gives us composite-space support for the "special" layer mode ops for free.
2017-02-17 10:20:04 -05:00
}
app: add gimp_layer_mode_get_included_region() Takes a layer mode and a composite mode, and returns the region included in the composition. Use this function in GimpOperationLayerMode, instead of testing for specific composite modes directly. Will also be used by the next commit. Indentation cleanup in gimp_layer_modes.h
2017-05-11 15:46:59 -04:00
GimpLayerCompositeRegion
gimp_layer_mode_get_included_region (GimpLayerMode mode,
GimpLayerCompositeMode composite_mode)
{
if (composite_mode == GIMP_LAYER_COMPOSITE_AUTO)
composite_mode = gimp_layer_mode_get_composite_mode (mode);
switch (composite_mode)
{
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
case GIMP_LAYER_COMPOSITE_UNION:
app: add gimp_layer_mode_get_included_region() Takes a layer mode and a composite mode, and returns the region included in the composition. Use this function in GimpOperationLayerMode, instead of testing for specific composite modes directly. Will also be used by the next commit. Indentation cleanup in gimp_layer_modes.h
2017-05-11 15:46:59 -04:00
return GIMP_LAYER_COMPOSITE_REGION_UNION;
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
case GIMP_LAYER_COMPOSITE_CLIP_TO_BACKDROP:
app: add gimp_layer_mode_get_included_region() Takes a layer mode and a composite mode, and returns the region included in the composition. Use this function in GimpOperationLayerMode, instead of testing for specific composite modes directly. Will also be used by the next commit. Indentation cleanup in gimp_layer_modes.h
2017-05-11 15:46:59 -04:00
return GIMP_LAYER_COMPOSITE_REGION_DESTINATION;
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
case GIMP_LAYER_COMPOSITE_CLIP_TO_LAYER:
app: add gimp_layer_mode_get_included_region() Takes a layer mode and a composite mode, and returns the region included in the composition. Use this function in GimpOperationLayerMode, instead of testing for specific composite modes directly. Will also be used by the next commit. Indentation cleanup in gimp_layer_modes.h
2017-05-11 15:46:59 -04:00
return GIMP_LAYER_COMPOSITE_REGION_SOURCE;
app, pdb, libgimp, plug-ins, menus: rename layer composite modes Our composite modes don't correspond directly to the Porter-Duff operators after which they're named, and these names aren't too descriptive anyway. Rename the composite modes as follows: Source Over => Union Source Atop => Clip to Backdrop Destination Atop => Clip to Layer Source In => Intersection Update relevant code, including UI text, enumerator names, function names, and action names.
2018-03-14 14:52:10 -04:00
case GIMP_LAYER_COMPOSITE_INTERSECTION:
app: add gimp_layer_mode_get_included_region() Takes a layer mode and a composite mode, and returns the region included in the composition. Use this function in GimpOperationLayerMode, instead of testing for specific composite modes directly. Will also be used by the next commit. Indentation cleanup in gimp_layer_modes.h
2017-05-11 15:46:59 -04:00
return GIMP_LAYER_COMPOSITE_REGION_INTERSECTION;
default:
g_return_val_if_reached (GIMP_LAYER_COMPOSITE_REGION_INTERSECTION);
}
}
Reference in a new issue Copy permalink