Blender V5.3
node_composite_rgb_curves.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2006 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "BLI_math_base.hh"
6#include "BLI_math_vector.hh"
8
10
11#include "NOD_multi_function.hh"
12
13#include "DNA_color_types.h"
14
15#include "BKE_colortools.hh"
16#include "BKE_node.hh"
17
18#include "GPU_material.hh"
19
20#include "COM_result.hh"
21
23
25
27{
28 b.is_function_node();
29 b.add_input<decl::Color>("Image"_ustr)
30 .default_value({1.0f, 1.0f, 1.0f, 1.0f})
31 .description("Image/Color input on which RGB color transformation will be applied");
32 b.add_input<decl::Float>("Factor"_ustr, "Fac"_ustr)
33 .default_value(1.0f)
34 .min(0.0f)
35 .max(1.0f)
37 .description("Amount of influence the node exerts on the image");
38 b.add_input<decl::Color>("Black Level"_ustr)
39 .default_value({0.0f, 0.0f, 0.0f, 1.0f})
40 .description("Input color that should be mapped to black");
41 b.add_input<decl::Color>("White Level"_ustr)
42 .default_value({1.0f, 1.0f, 1.0f, 1.0f})
43 .description("Input color that should be mapped to white");
44 b.add_output<decl::Color>("Image"_ustr);
45}
46
47static void node_init(bNodeTree * /*ntree*/, bNode *node)
48{
49 node->storage = BKE_curvemapping_add(4, 0.0f, 0.0f, 1.0f, 1.0f);
50}
51
52using namespace blender::compositor;
53
55{
56 return static_cast<CurveMapping *>(node.storage);
57}
58
59static int node_gpu_material(GPUMaterial *material,
60 bNode *node,
61 bNodeExecData * /*execdata*/,
62 GPUNodeStack *inputs,
63 GPUNodeStack *outputs)
64{
65 CurveMapping *curve_mapping = get_curve_mapping(*node);
66
67 BKE_curvemapping_init(curve_mapping);
68 BKE_curvemapping_premultiply(curve_mapping, true);
69 float *band_values;
70 int band_size;
71 BKE_curvemapping_table_RGBA(curve_mapping, &band_values, &band_size);
72 float band_layer;
73 GPUNodeLink *band_texture = GPU_color_band(material, band_size, band_values, &band_layer);
74
75 float start_slopes[CM_TOT];
76 float end_slopes[CM_TOT];
77 BKE_curvemapping_compute_slopes(curve_mapping, start_slopes, end_slopes);
78 float range_minimums[CM_TOT];
79 BKE_curvemapping_get_range_minimums(curve_mapping, range_minimums);
80 float range_dividers[CM_TOT];
81 BKE_curvemapping_compute_range_dividers(curve_mapping, range_dividers);
82
83 if (curve_mapping->tone == CURVE_TONE_FILMLIKE) {
84 return GPU_stack_link(material,
85 node,
86 "curves_film_like_compositor",
87 inputs,
88 outputs,
89 band_texture,
90 GPU_constant(&band_layer),
91 GPU_uniform(&range_minimums[3]),
92 GPU_uniform(&range_dividers[3]),
93 GPU_uniform(&start_slopes[3]),
94 GPU_uniform(&end_slopes[3]));
95 }
96
97 const float min = 0.0f;
98 const float max = 1.0f;
99 GPU_link(material,
100 "clamp_value",
101 GPU_node_get_input_link(*node, inputs, "Fac"),
104 &GPU_node_get_input(*node, inputs, "Fac").link);
105
106 /* If the RGB curves do nothing, use a function that skips RGB computations. */
107 if (BKE_curvemapping_is_map_identity(curve_mapping, 0) &&
108 BKE_curvemapping_is_map_identity(curve_mapping, 1) &&
109 BKE_curvemapping_is_map_identity(curve_mapping, 2))
110 {
111 return GPU_stack_link(material,
112 node,
113 "curves_combined_only_compositor",
114 inputs,
115 outputs,
116 band_texture,
117 GPU_constant(&band_layer),
118 GPU_uniform(&range_minimums[3]),
119 GPU_uniform(&range_dividers[3]),
120 GPU_uniform(&start_slopes[3]),
121 GPU_uniform(&end_slopes[3]));
122 }
123
124 return GPU_stack_link(material,
125 node,
126 "curves_combined_rgb_compositor",
127 inputs,
128 outputs,
129 band_texture,
130 GPU_constant(&band_layer),
131 GPU_uniform(range_minimums),
132 GPU_uniform(range_dividers),
133 GPU_uniform(start_slopes),
134 GPU_uniform(end_slopes));
135}
136
137static float4 curves_rgba(const CurveMapping *curve_mapping,
138 const float4 &color,
139 const float factor,
140 const float4 &black,
141 const float4 &white)
142{
143 float3 black_white_scale;
144 BKE_curvemapping_set_black_white_ex(black, white, black_white_scale);
145
147 BKE_curvemapping_evaluate_premulRGBF_ex(curve_mapping, result, color, black, black_white_scale);
148 return float4(math::interpolate(color.xyz(), result, math::clamp(factor, 0.0f, 1.0f)), color.w);
149}
150
152
154{
155 CurveMapping *curve_mapping = get_curve_mapping(builder.node());
156 BKE_curvemapping_init(curve_mapping);
157 BKE_curvemapping_premultiply(curve_mapping, false);
158
160 return mf::build::SI4_SO<Color, float, Color, Color, Color>(
161 "RGB Curves",
162 /* Take ownership of the tree because it contains the curve mapping. */
163 [curve_mapping, tree = builder.shared_tree()](const Color &color,
164 const float factor,
165 const Color &black,
166 const Color &white) -> Color {
167 return Color(
168 curves_rgba(curve_mapping, float4(color), factor, float4(black), float4(white)));
169 },
170 mf::build::exec_presets::SomeSpanOrSingle<0>());
171 });
172}
173
174static void node_register()
175{
176 static bke::bNodeType ntype;
177
178 cmp_node_type_base(&ntype, "CompositorNodeCurveRGB"_ustr, CMP_NODE_CURVE_RGB);
179 ntype.ui_name = "RGB Curves";
180 ntype.ui_description = "Perform level adjustments on each color channel of an image";
181 ntype.enum_name_legacy = "CURVE_RGB";
183 ntype.declare = node_declare;
185 ntype.initfunc = node_init;
189
191}
193
194} // namespace blender::nodes::node_composite_rgb_curves_cc
#define NODE_CLASS_OP_COLOR
Definition BKE_node.hh:480
#define CMP_NODE_CURVE_RGB
#define CM_TOT
#define NOD_REGISTER_NODE(REGISTER_FUNC)
btScalar max
void construct_and_set_matching_fn_cb(Fn &&create_multi_function)
const std::shared_ptr< const bNodeTree > & shared_tree()
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
void node_type_storage(bNodeType &ntype, std::optional< StringRefNull > storagename, void(*freefunc)(bNode *node), void(*copyfunc)(bNodeTree *dest_ntree, bNode *dest_node, const bNode *src_node))
Definition node.cc:6166
ColorSceneLinear4f< eAlpha::Premultiplied > Color
Definition COM_result.hh:96
T clamp(const T &a, const T &min, const T &max)
T interpolate(const T &a, const T &b, const FactorT &t)
static CurveMapping * get_curve_mapping(const bNode &node)
static void node_declare(NodeDeclarationBuilder &b)
static void node_init(bNodeTree *, bNode *node)
static float4 curves_rgba(const CurveMapping *curve_mapping, const float4 &color, const float factor, const float4 &black, const float4 &white)
static void node_build_multi_function(nodes::NodeMultiFunctionBuilder &builder)
static int node_gpu_material(GPUMaterial *material, bNode *node, bNodeExecData *, GPUNodeStack *inputs, GPUNodeStack *outputs)
CurveMapping * BKE_curvemapping_add(int tot, float minx, float miny, float maxx, float maxy)
Definition colortools.cc:99
bool GPU_stack_link(GPUMaterial *mat, const bNode *node, const char *name, GPUNodeStack *in, GPUNodeStack *out,...)
GPUNodeLink * GPU_node_get_input_link(const bNode &node, GPUNodeStack inputs[], StringRef identifier)
@ CURVE_TONE_FILMLIKE
GPUNodeStack & GPU_node_get_input(const bNode &node, GPUNodeStack inputs[], StringRef identifier)
void BKE_curvemapping_premultiply(CurveMapping *cumap, bool restore)
GPUNodeLink * GPU_color_band(GPUMaterial *mat, int size, float *pixels, float *r_row)
GPUNodeLink * GPU_uniform(const float *num)
void BKE_curvemapping_init(CurveMapping *cumap)
GPUNodeLink * GPU_constant(const float *num)
bool GPU_link(GPUMaterial *mat, const char *name,...)
void node_free_curves(bNode *node)
Definition node_util.cc:40
void node_copy_curves(bNodeTree *, bNode *dest_node, const bNode *src_node)
Definition node_util.cc:52
void BKE_curvemapping_set_black_white_ex(const float black[3], const float white[3], float r_bwmul[3])
void BKE_curvemapping_table_RGBA(const CurveMapping *cumap, float **array, int *size)
void BKE_curvemapping_compute_slopes(const CurveMapping *curve_mapping, float start_slopes[4], float end_slopes[4])
void BKE_curvemapping_compute_range_dividers(const CurveMapping *curve_mapping, float dividers[4])
bool BKE_curvemapping_is_map_identity(const CurveMapping *curve_mapping, int index)
@ PROP_FACTOR
Definition RNA_types.hh:308
void BKE_curvemapping_get_range_minimums(const CurveMapping *curve_mapping, float minimums[4])
void BKE_curvemapping_evaluate_premulRGBF_ex(const CurveMapping *cumap, float vecout[3], const float vecin[3], const float black[3], const float bwmul[3])
void cmp_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
#define min(a, b)
Definition sort.cc:38
eCurveMappingTone tone
static constexpr int _200
Definition BKE_node.hh:248
Defines a node type.
Definition BKE_node.hh:265
std::string ui_description
Definition BKE_node.hh:271
NodeGPUExecFunction gpu_fn
Definition BKE_node.hh:373
NodeMultiFunctionBuildFunction build_multi_function
Definition BKE_node.hh:382
void(*) initfunc(bNodeTree *ntree, bNode *node)
Definition BKE_node.hh:320
const char * enum_name_legacy
Definition BKE_node.hh:274
NodeDeclareFunction declare
Definition BKE_node.hh:393