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

1464 lines
52 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
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <glib-object.h>
#include "../operations-types.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 |
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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.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: 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: 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
GIMP_LAYER_MODE_FLAG_COMPOSITE_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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
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_mode = GIMP_LAYER_COMPOSITE_SRC_OVER
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: 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_PAINT |
GIMP_LAYER_MODE_CONTEXT_FADE,
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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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 legacy color-erase mode from the layer mode combo It was accidentally made applicable to layers by commit 7d345071c7d1c0de007e6966f963fae06f9a2159. Only the non-legacy color-erase mode shoule be applicable to layers (since 2.8 didn't allow it as a layer mode), while the legacy mode is only available for painting, and in the fade dialog.
2017-10-16 16:15:00 -04:00
.context = GIMP_LAYER_MODE_CONTEXT_PAINT |
GIMP_LAYER_MODE_CONTEXT_FADE,
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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: put BLEND_SPACE_IMMUTABLE back for NORMAL
2017-02-26 16:43:59 +01: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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.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: 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_PAINT |
GIMP_LAYER_MODE_CONTEXT_FADE,
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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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,
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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 |
GIMP_LAYER_MODE_FLAG_SUBTRACTIVE,
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: 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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.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",
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE,
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.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 |
GIMP_LAYER_MODE_FLAG_SUBTRACTIVE,
.context = GIMP_LAYER_MODE_CONTEXT_ALL,
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_ATOP
},
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: 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
.flags = GIMP_LAYER_MODE_FLAG_BLEND_SPACE_IMMUTABLE |
GIMP_LAYER_MODE_FLAG_COMPOSITE_MODE_IMMUTABLE,
.context = GIMP_LAYER_MODE_CONTEXT_GROUP,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.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: 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_FADE,
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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
.composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
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: 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: 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
GIMP_LAYER_MODE_FLAG_COMPOSITE_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_FADE,
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
.paint_composite_mode = GIMP_LAYER_COMPOSITE_SRC_OVER,
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_mode = GIMP_LAYER_COMPOSITE_SRC_OVER
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: 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,
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: Bug 753163 - Add blend mode "RGB Luminance" This adds a blend mode similar to CIE Luminance - but that does not alter saturation.
2017-02-20 05:26:51 -05: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
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_EXCLUSION,
app: remove mono-mix layer mode This effectively reverts commit c6c0899655740869ef401599e16d9c8e16853f80. Removing due to lack of consensus. We can always re-add it in the future if we decide we want it.
2017-03-15 14:52:14 -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
};
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: 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: 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_COMPOSITE_SRC_OVER;
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)
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 GIMP_LAYER_COMPOSITE_SRC_OVER;
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 *
gimp_layer_mode_get_format (GimpLayerMode mode,
GimpLayerColorSpace composite_space,
GimpLayerColorSpace blend_space,
const Babl *preferred_format)
{
/* 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);
switch (composite_space)
{
case GIMP_LAYER_COLOR_SPACE_AUTO:
/* compositing is color-space agnostic. try to return the preferred
* format, and fall back to linear.
*/
if (preferred_format == babl_format ("RGBA float") ||
preferred_format == babl_format ("R'G'B'A float"))
{
return preferred_format;
}
else
{
return babl_format ("RGBA float");
}
case GIMP_LAYER_COLOR_SPACE_RGB_LINEAR:
return babl_format ("RGBA float");
case GIMP_LAYER_COLOR_SPACE_RGB_PERCEPTUAL:
return babl_format ("R'G'B'A float");
case GIMP_LAYER_COLOR_SPACE_LAB:
return babl_format ("CIE Lab alpha float");
}
g_return_val_if_reached (babl_format ("RGBA float"));
}
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)
{
case GIMP_LAYER_COMPOSITE_SRC_OVER:
return GIMP_LAYER_COMPOSITE_REGION_UNION;
case GIMP_LAYER_COMPOSITE_SRC_ATOP:
return GIMP_LAYER_COMPOSITE_REGION_DESTINATION;
case GIMP_LAYER_COMPOSITE_DST_ATOP:
return GIMP_LAYER_COMPOSITE_REGION_SOURCE;
case GIMP_LAYER_COMPOSITE_SRC_IN:
return GIMP_LAYER_COMPOSITE_REGION_INTERSECTION;
default:
g_return_val_if_reached (GIMP_LAYER_COMPOSITE_REGION_INTERSECTION);
}
}
Reference in a new issue Copy permalink