Blender V5.3
node_composite_color_balance.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_color.hh"
8#include "BLI_math_vector.hh"
10
11#include "BKE_node.hh"
12#include "BKE_node_runtime.hh"
13
14#include "NOD_multi_function.hh"
15
16#include "RNA_access.hh"
17
18#include "UI_interface.hh"
20#include "UI_resources.hh"
21
22#include "GPU_material.hh"
23
25
26#include "COM_result.hh"
27
29
31
32static const EnumPropertyItem type_items[] = {
33 {CMP_NODE_COLOR_BALANCE_LGG, "LIFT_GAMMA_GAIN", 0, N_("Lift/Gamma/Gain"), ""},
35 "OFFSET_POWER_SLOPE",
36 0,
37 N_("Offset/Power/Slope (ASC-CDL)"),
38 N_("ASC-CDL standard color correction")},
40 "WHITEPOINT",
41 0,
42 N_("White Point"),
43 N_("Chromatic adaption from a different white point")},
44 {0, nullptr, 0, nullptr, nullptr},
45};
46
48{
49 b.is_function_node();
50 b.use_custom_socket_order();
51 b.allow_any_socket_order();
52
53 b.add_input<decl::Color>("Image"_ustr).default_value({1.0f, 1.0f, 1.0f, 1.0f}).hide_value();
54 b.add_output<decl::Color>("Image"_ustr).align_with_previous();
55
56 b.add_input<decl::Float>("Factor"_ustr, "Fac"_ustr)
57 .default_value(1.0f)
58 .min(0.0f)
59 .max(1.0f)
61
62 b.add_input<decl::Menu>("Type"_ustr)
63 .default_value(CMP_NODE_COLOR_BALANCE_LGG)
64 .static_items(type_items)
66
67 b.add_input<decl::Float>("Lift"_ustr, "Base Lift"_ustr)
68 .default_value(0.0f)
69 .min(-1.0f)
70 .max(1.0f)
72 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_LGG)
73 .description("Correction for shadows");
74 b.add_input<decl::Color>("Lift"_ustr, "Color Lift"_ustr)
75 .default_value({1.0f, 1.0f, 1.0f, 1.0f})
76 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_LGG)
77 .description("Correction for shadows");
78 b.add_input<decl::Float>("Gamma"_ustr, "Base Gamma"_ustr)
79 .default_value(1.0f)
80 .min(0.0f)
81 .max(2.0f)
83 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_LGG)
84 .description("Correction for midtones");
85 b.add_input<decl::Color>("Gamma"_ustr, "Color Gamma"_ustr)
86 .default_value({1.0f, 1.0f, 1.0f, 1.0f})
87 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_LGG)
88 .description("Correction for midtones");
89 b.add_input<decl::Float>("Gain"_ustr, "Base Gain"_ustr)
90 .default_value(1.0f)
91 .min(0.0f)
92 .max(2.0f)
94 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_LGG)
95 .description("Correction for highlights");
96 b.add_input<decl::Color>("Gain"_ustr, "Color Gain"_ustr)
97 .default_value({1.0f, 1.0f, 1.0f, 1.0f})
98 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_LGG)
99 .description("Correction for highlights");
100
101 b.add_input<decl::Float>("Offset"_ustr, "Base Offset"_ustr)
102 .default_value(0.0f)
103 .min(-1.0f)
104 .max(1.0f)
106 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_ASC_CDL)
107 .description("Correction for shadows");
108 b.add_input<decl::Color>("Offset"_ustr, "Color Offset"_ustr)
109 .default_value({0.0f, 0.0f, 0.0f, 1.0f})
110 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_ASC_CDL)
111 .description("Correction for shadows");
112 b.add_input<decl::Float>("Power"_ustr, "Base Power"_ustr)
113 .default_value(1.0f)
114 .min(0.0f)
115 .max(2.0f)
117 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_ASC_CDL)
118 .description("Correction for midtones");
119 b.add_input<decl::Color>("Power"_ustr, "Color Power"_ustr)
120 .default_value({1.0f, 1.0f, 1.0f, 1.0f})
121 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_ASC_CDL)
122 .description("Correction for midtones");
123 b.add_input<decl::Float>("Slope"_ustr, "Base Slope"_ustr)
124 .default_value(1.0f)
125 .min(0.0f)
126 .max(2.0f)
128 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_ASC_CDL)
129 .description("Correction for highlights");
130 b.add_input<decl::Color>("Slope"_ustr, "Color Slope"_ustr)
131 .default_value({1.0f, 1.0f, 1.0f, 1.0f})
132 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_ASC_CDL)
133 .description("Correction for highlights");
134
135 PanelDeclarationBuilder &input_panel = b.add_panel("Input"_ustr);
136 input_panel.add_input<decl::Float>("Temperature"_ustr, "Input Temperature"_ustr)
137 .default_value(6500.0f)
139 .min(1800.0f)
140 .max(100000.0f)
141 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_WHITEPOINT)
142 .description("Color temperature of the input's white point");
143 input_panel.add_input<decl::Float>("Tint"_ustr, "Input Tint"_ustr)
144 .default_value(10.0f)
146 .min(-150.0f)
147 .max(150.0f)
148 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_WHITEPOINT)
149 .description("Color tint of the input's white point (the default of 10 matches daylight)");
150 input_panel.add_layout([](ui::Layout &layout, bContext * /*C*/, PointerRNA *ptr) {
151 ui::Layout &split = layout.split(0.2f, false);
152 template_crypto_picker(&split, ptr, "input_whitepoint", ICON_EYEDROPPER);
153 });
154
155 PanelDeclarationBuilder &output_panel = b.add_panel("Output"_ustr);
156 output_panel.add_input<decl::Float>("Temperature"_ustr, "Output Temperature"_ustr)
157 .default_value(6500.0f)
159 .min(1800.0f)
160 .max(100000.0f)
161 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_WHITEPOINT)
162 .description("Color temperature of the output's white point");
163 output_panel.add_input<decl::Float>("Tint"_ustr, "Output Tint"_ustr)
164 .default_value(10.0f)
166 .min(-150.0f)
167 .max(150.0f)
168 .usage_by_menu("Type"_ustr, CMP_NODE_COLOR_BALANCE_WHITEPOINT)
169 .description("Color tint of the output's white point (the default of 10 matches daylight)");
170 output_panel.add_layout([](ui::Layout &layout, bContext * /*C*/, PointerRNA *ptr) {
171 ui::Layout &split = layout.split(0.2f, false);
172 template_crypto_picker(&split, ptr, "output_whitepoint", ICON_EYEDROPPER);
173 });
174}
175
176static float3x3 get_white_point_matrix(const float input_temperature,
177 const float input_tint,
178 const float output_temperature,
179 const float output_tint)
180{
183 const float3 input = math::whitepoint_from_temp_tint(input_temperature, input_tint);
184 const float3 output = math::whitepoint_from_temp_tint(output_temperature, output_tint);
185 const float3x3 adaption = math::chromatic_adaption_matrix(input, output);
186 return xyz_to_scene * adaption * scene_to_xyz;
187}
188
189static int node_gpu_material(GPUMaterial *material,
190 bNode *node,
191 bNodeExecData * /*execdata*/,
192 GPUNodeStack *inputs,
193 GPUNodeStack *outputs)
194{
195 const bNodeSocket &type = *node->input_by_identifier("Type"_ustr);
196 const bool is_white_point = !type.is_directly_linked() &&
197 type.default_value_typed<bNodeSocketValueMenu>()->value ==
199
200 const bNodeSocket &input_temperature = *node->input_by_identifier("Input Temperature"_ustr);
201 const bNodeSocket &input_tint = *node->input_by_identifier("Input Tint"_ustr);
202 const bNodeSocket &output_temperature = *node->input_by_identifier("Output Temperature"_ustr);
203 const bNodeSocket &output_tint = *node->input_by_identifier("Output Tint"_ustr);
204
205 /* As an optimization for white point balancing, if all inputs are constant, compute the white
206 * point matrix on the host and pass it to the shader. */
207 if (is_white_point && !input_temperature.is_directly_linked() &&
208 !input_tint.is_directly_linked() && !output_temperature.is_directly_linked() &&
209 !output_tint.is_directly_linked())
210 {
211 const float4x4 white_point_matrix = float4x4(get_white_point_matrix(
212 input_temperature.default_value_typed<bNodeSocketValueFloat>()->value,
213 input_tint.default_value_typed<bNodeSocketValueFloat>()->value,
214 output_temperature.default_value_typed<bNodeSocketValueFloat>()->value,
215 output_tint.default_value_typed<bNodeSocketValueFloat>()->value));
216
217 return GPU_stack_link(material,
218 node,
219 "node_composite_color_balance_white_point_constant",
220 inputs,
221 outputs,
222 GPU_uniform(white_point_matrix.base_ptr()));
223 }
224
227 return GPU_stack_link(material,
228 node,
229 "node_composite_color_balance",
230 inputs,
231 outputs,
232 GPU_uniform(scene_to_xyz.base_ptr()),
233 GPU_uniform(xyz_to_scene.base_ptr()));
234}
235
237 const float base_lift,
238 const float4 color_lift,
239 const float base_gamma,
240 const float4 color_gamma,
241 const float base_gain,
242 const float4 color_gain)
243{
244 const float3 lift = base_lift + color_lift.xyz();
245 const float3 lift_balanced = ((color.xyz() - 1.0f) * (2.0f - lift)) + 1.0f;
246
247 const float3 gain = base_gain * color_gain.xyz();
248 const float3 gain_balanced = math::max(float3(0.0f), lift_balanced * gain);
249
250 const float3 gamma = base_gamma * color_gamma.xyz();
251 const float3 gamma_balanced = math::pow(gain_balanced, 1.0f / math::max(gamma, float3(1e-6f)));
252
253 return float4(gamma_balanced, color.w);
254}
255
257 const float base_offset,
258 const float4 color_offset,
259 const float base_power,
260 const float4 color_power,
261 const float base_slope,
262 const float4 color_slope)
263{
264 const float3 slope = base_slope * color_slope.xyz();
265 const float3 slope_balanced = color.xyz() * slope;
266
267 const float3 offset = base_offset + color_offset.xyz();
268 const float3 offset_balanced = slope_balanced + offset;
269
270 const float3 power = base_power * color_power.xyz();
271 const float3 power_balanced = math::pow(math::max(offset_balanced, float3(0.0f)), power);
272
273 return float4(power_balanced, color.w);
274}
275
277 const float factor,
278 const float3x3 white_point_matrix)
279{
280 const float3 balanced = white_point_matrix * color.xyz();
281 return float4(math::interpolate(color.xyz(), balanced, math::min(factor, 1.0f)), color.w);
282}
283
285 const float input_temperature,
286 const float input_tint,
287 const float output_temperature,
288 const float output_tint,
289 const float3x3 &scene_to_xyz,
290 const float3x3 &xyz_to_scene)
291{
292 const float3 input = math::whitepoint_from_temp_tint(input_temperature, input_tint);
293 const float3 output = math::whitepoint_from_temp_tint(output_temperature, output_tint);
294 const float3x3 adaption = math::chromatic_adaption_matrix(input, output);
295 const float3x3 white_point_matrix = xyz_to_scene * adaption * scene_to_xyz;
296
297 const float3 balanced = white_point_matrix * color.xyz();
298 return float4(balanced, color.w);
299}
300
302 const float factor,
303 const CMPNodeColorBalanceMethod type,
304 const float base_lift,
305 const float4 color_lift,
306 const float base_gamma,
307 const float4 color_gamma,
308 const float base_gain,
309 const float4 color_gain,
310 const float base_offset,
311 const float4 color_offset,
312 const float base_power,
313 const float4 color_power,
314 const float base_slope,
315 const float4 color_slope,
316 const float input_temperature,
317 const float input_tint,
318 const float output_temperature,
319 const float output_tint,
320 const float3x3 scene_to_xyz,
321 const float3x3 xyz_to_scene)
322{
323 float4 result = float4(0.0f);
324 switch (type) {
327 color, base_lift, color_lift, base_gamma, color_gamma, base_gain, color_gain);
328 break;
331 color, base_offset, color_offset, base_power, color_power, base_slope, color_slope);
332 break;
335 input_temperature,
336 input_tint,
337 output_temperature,
338 output_tint,
339 scene_to_xyz,
340 xyz_to_scene);
341 break;
342 }
343
344 return float4(math::interpolate(color.xyz(), result.xyz(), math::min(factor, 1.0f)), color.w);
345}
346
348
349class ColorBalanceFunction : public mf::MultiFunction {
350 public:
352 {
353 static const mf::Signature signature = []() {
354 mf::Signature signature;
355 mf::SignatureBuilder builder{"Color Balance", signature};
356 builder.single_input<Color>("Color");
357 builder.single_input<float>("Factor");
358 builder.single_input<MenuValue>("Type");
359
360 builder.single_input<float>("Base Lift");
361 builder.single_input<Color>("Color Lift");
362 builder.single_input<float>("Base Gamma");
363 builder.single_input<Color>("Color Gamma");
364 builder.single_input<float>("Base Gain");
365 builder.single_input<Color>("Color Gain");
366
367 builder.single_input<float>("Base Offset");
368 builder.single_input<Color>("Color Offset");
369 builder.single_input<float>("Base Power");
370 builder.single_input<Color>("Color Power");
371 builder.single_input<float>("Base Slope");
372 builder.single_input<Color>("Color Slope");
373
374 builder.single_input<float>("Input Temperature");
375 builder.single_input<float>("Input Tint");
376 builder.single_input<float>("Output Temperature");
377 builder.single_input<float>("Output Tint");
378
379 builder.single_output<Color>("Result");
380 return signature;
381 }();
382 this->set_signature(&signature);
383 }
384
385 void call(const IndexMask &mask, mf::Params params, mf::Context /*context*/) const override
386 {
387 const VArray<Color> color_array = params.readonly_single_input<Color>(0, "Color");
388 const VArray<float> factor_array = params.readonly_single_input<float>(1, "Factor");
389 const VArray<MenuValue> type_array = params.readonly_single_input<MenuValue>(2, "Type");
390
391 const VArray<float> base_lift_array = params.readonly_single_input<float>(3, "Base Lift");
392 const VArray<Color> color_lift_array = params.readonly_single_input<Color>(4, "Color Lift");
393 const VArray<float> base_gamma_array = params.readonly_single_input<float>(5, "Base Gamma");
394 const VArray<Color> color_gamma_array = params.readonly_single_input<Color>(6, "Color Gamma");
395 const VArray<float> base_gain_array = params.readonly_single_input<float>(7, "Base Gain");
396 const VArray<Color> color_gain_array = params.readonly_single_input<Color>(8, "Color Gain");
397
398 const VArray<float> base_offset_array = params.readonly_single_input<float>(9, "Base Offset");
399 const VArray<Color> color_offset_array = params.readonly_single_input<Color>(10,
400 "Color Offset");
401 const VArray<float> base_power_array = params.readonly_single_input<float>(11, "Base Power");
402 const VArray<Color> color_power_array = params.readonly_single_input<Color>(12, "Color Power");
403 const VArray<float> base_slope_array = params.readonly_single_input<float>(13, "Base Slope");
404 const VArray<Color> color_slope_array = params.readonly_single_input<Color>(14, "Color Slope");
405
406 const VArray<float> input_temperature_array = params.readonly_single_input<float>(
407 15, "Input Temperature");
408 const VArray<float> input_tint_array = params.readonly_single_input<float>(16, "Input Tint");
409 const VArray<float> output_temperature_array = params.readonly_single_input<float>(
410 17, "Output Temperature");
411 const VArray<float> output_tint_array = params.readonly_single_input<float>(18, "Output Tint");
412
413 MutableSpan<Color> result = params.uninitialized_single_output<Color>(19, "Result");
414
415 const std::optional<MenuValue> type_single = type_array.get_if_single();
416 const std::optional<float> input_temperature_single = input_temperature_array.get_if_single();
417 const std::optional<float> input_tint_single = input_tint_array.get_if_single();
418 const std::optional<float> output_temperature_single =
419 output_temperature_array.get_if_single();
420 const std::optional<float> output_tint_single = output_tint_array.get_if_single();
421
422 const bool is_white_point = type_single.has_value() &&
423 type_single.value().value == CMP_NODE_COLOR_BALANCE_WHITEPOINT;
424
425 /* As an optimization for white point balancing, if all inputs are single, compute the white
426 * point matrix outside of the loop. */
427 if (is_white_point && input_temperature_single.has_value() && input_tint_single.has_value() &&
428 output_temperature_single.has_value() && output_tint_single.has_value())
429 {
430 const float3x3 white_point_matrix = get_white_point_matrix(input_temperature_single.value(),
431 input_tint_single.value(),
432 output_temperature_single.value(),
433 output_tint_single.value());
434 mask.foreach_index([&](const int64_t i) {
435 result[i] = Color(
436 white_point_constant(float4(color_array[i]), factor_array[i], white_point_matrix));
437 });
438 }
439 else {
442
443 bool all_but_color_single_value = true;
444 for (int i = 0; i < 19; i++) {
445 if (i == 1) {
446 continue;
447 }
448 if (!params.readonly_single_input(i).is_single()) {
449 all_but_color_single_value = false;
450 break;
451 }
452 }
453
454 if (all_but_color_single_value) {
455 const float factor = factor_array.get_internal_single();
456 const float type = CMPNodeColorBalanceMethod(type_array.get_internal_single().value);
457 const float base_lift = base_lift_array.get_internal_single();
458 const float4 color_lift = float4(color_lift_array.get_internal_single());
459 const float base_gamma = base_gamma_array.get_internal_single();
460 const float4 color_gamma = float4(color_gamma_array.get_internal_single());
461 const float base_gain = base_gain_array.get_internal_single();
462 const float4 color_gain = float4(color_gain_array.get_internal_single());
463 const float base_offset = base_offset_array.get_internal_single();
464 const float4 color_offset = float4(color_offset_array.get_internal_single());
465 const float base_power = base_power_array.get_internal_single();
466 const float4 color_power = float4(color_power_array.get_internal_single());
467 const float base_slope = base_slope_array.get_internal_single();
468 const float4 color_slope = float4(color_slope_array.get_internal_single());
469 const float input_temperature = input_temperature_array.get_internal_single();
470 const float input_tint = input_tint_array.get_internal_single();
471 const float output_temperature = output_temperature_array.get_internal_single();
472 const float output_tint = output_tint_array.get_internal_single();
473
474 mask.foreach_index([&](const int64_t i) {
475 result[i] = Color(color_balance(float4(color_array[i]),
476 factor,
478 base_lift,
479 color_lift,
480 base_gamma,
481 color_gamma,
482 base_gain,
483 color_gain,
484 base_offset,
485 color_offset,
486 base_power,
487 color_power,
488 base_slope,
489 color_slope,
490 input_temperature,
491 input_tint,
492 output_temperature,
493 output_tint,
494 scene_to_xyz,
495 xyz_to_scene));
496 });
497 }
498 else {
499 mask.foreach_index([&](const int64_t i) {
500 result[i] = Color(color_balance(float4(color_array[i]),
501 factor_array[i],
502 CMPNodeColorBalanceMethod(type_array[i].value),
503 base_lift_array[i],
504 float4(color_lift_array[i]),
505 base_gamma_array[i],
506 float4(color_gamma_array[i]),
507 base_gain_array[i],
508 float4(color_gain_array[i]),
509 base_offset_array[i],
510 float4(color_offset_array[i]),
511 base_power_array[i],
512 float4(color_power_array[i]),
513 base_slope_array[i],
514 float4(color_slope_array[i]),
515 input_temperature_array[i],
516 input_tint_array[i],
517 output_temperature_array[i],
518 output_tint_array[i],
519 scene_to_xyz,
520 xyz_to_scene));
521 });
522 }
523 }
524 }
525};
526
528{
529 const static ColorBalanceFunction function;
530 builder.set_matching_fn(function);
531}
532
533static void node_register()
534{
535 static bke::bNodeType ntype;
536
537 cmp_node_type_base(&ntype, "CompositorNodeColorBalance"_ustr, CMP_NODE_COLORBALANCE);
538 ntype.ui_name = "Color Balance";
539 ntype.ui_description = "Adjust color and values";
540 ntype.enum_name_legacy = "COLORBALANCE";
542 ntype.declare = node_declare;
545
547}
549
550} // namespace blender::nodes::node_composite_color_balance_cc
#define NODE_CLASS_OP_COLOR
Definition BKE_node.hh:480
#define CMP_NODE_COLORBALANCE
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define output
void set_signature(const Signature *signature)
DeclType::Builder & add_input(UString name, UString identifier=""_ustr)
void add_layout(std::function< void(ui::Layout &, bContext *, PointerRNA *)> draw)
void set_matching_fn(const mf::MultiFunction *fn)
void call(const IndexMask &mask, mf::Params params, mf::Context) const override
ccl_device_inline float2 power(const float2 v, const float e)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
ColorSceneLinear4f< eAlpha::Premultiplied > Color
Definition COM_result.hh:96
void split(const std::string &s, const char delim, std::vector< std::string > &tokens)
Definition abc_util.cc:68
T pow(const T &x, const T &power)
float3 whitepoint_from_temp_tint(float temperature, float tint)
T min(const T &a, const T &b)
T interpolate(const T &a, const T &b, const FactorT &t)
float3x3 chromatic_adaption_matrix(const float3 &from_XYZ, const float3 &to_XYZ)
T max(const T &a, const T &b)
static float3x3 get_white_point_matrix(const float input_temperature, const float input_tint, const float output_temperature, const float output_tint)
static void node_build_multi_function(nodes::NodeMultiFunctionBuilder &builder)
static float4 offset_power_slope(const float4 color, const float base_offset, const float4 color_offset, const float base_power, const float4 color_power, const float base_slope, const float4 color_slope)
static int node_gpu_material(GPUMaterial *material, bNode *node, bNodeExecData *, GPUNodeStack *inputs, GPUNodeStack *outputs)
static float4 white_point_constant(const float4 color, const float factor, const float3x3 white_point_matrix)
static float4 white_point_variable(const float4 color, const float input_temperature, const float input_tint, const float output_temperature, const float output_tint, const float3x3 &scene_to_xyz, const float3x3 &xyz_to_scene)
static float4 color_balance(const float4 color, const float factor, const CMPNodeColorBalanceMethod type, const float base_lift, const float4 color_lift, const float base_gamma, const float4 color_gamma, const float base_gain, const float4 color_gain, const float base_offset, const float4 color_offset, const float base_power, const float4 color_power, const float base_slope, const float4 color_slope, const float input_temperature, const float input_tint, const float output_temperature, const float output_tint, const float3x3 scene_to_xyz, const float3x3 xyz_to_scene)
static float4 lift_gamma_gain(const float4 color, const float base_lift, const float4 color_lift, const float base_gamma, const float4 color_gamma, const float base_gain, const float4 color_gain)
bool GPU_stack_link(GPUMaterial *mat, const bNode *node, const char *name, GPUNodeStack *in, GPUNodeStack *out,...)
__int64 int64_t
Definition BKE_text.h:90
MatBase< float, 4, 4 > float4x4
GPUNodeLink * GPU_uniform(const float *num)
VecBase< float, 4 > float4
MatBase< float, 3, 3 > float3x3
float3x3 IMB_colormanagement_get_scene_linear_to_xyz()
float3x3 IMB_colormanagement_get_xyz_to_scene_linear()
CMPNodeColorBalanceMethod
@ CMP_NODE_COLOR_BALANCE_WHITEPOINT
@ CMP_NODE_COLOR_BALANCE_LGG
@ CMP_NODE_COLOR_BALANCE_ASC_CDL
VecBase< float, 3 > float3
@ PROP_FACTOR
Definition RNA_types.hh:308
@ PROP_COLOR_TEMPERATURE
Definition RNA_types.hh:347
void cmp_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
const T * base_ptr() const
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
const char * enum_name_legacy
Definition BKE_node.hh:274
NodeDeclareFunction declare
Definition BKE_node.hh:393
Layout & split(float percentage, bool align)
#define N_(msgid)