Blender V5.3
node_fn_separate_color.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
6
7#include "BLI_math_color_c.hh"
8
10#include "UI_resources.hh"
11
12#include "NOD_rna_define.hh"
13
14#include "RNA_enum_types.hh"
15
17
19
21{
22 b.is_function_node();
23 b.add_input<decl::Color>("Color"_ustr).default_value({1.0f, 1.0f, 1.0f, 1.0f});
24 b.add_output<decl::Float>("Red"_ustr).label_fn([](const bNode &node) {
25 switch (node_storage(node).mode) {
27 default:
28 return IFACE_("Red");
31 return IFACE_("Hue");
32 }
33 });
34 b.add_output<decl::Float>("Green"_ustr).label_fn([](const bNode &node) {
35 switch (node_storage(node).mode) {
37 default:
38 return IFACE_("Green");
41 return IFACE_("Saturation");
42 }
43 });
44 b.add_output<decl::Float>("Blue"_ustr).label_fn([](const bNode &node) {
45 switch (node_storage(node).mode) {
47 default:
48 return IFACE_("Blue");
50 return CTX_IFACE_(BLT_I18NCONTEXT_COLOR, "Value");
52 return IFACE_("Lightness");
53 }
54 });
55 b.add_output<decl::Float>("Alpha"_ustr);
56};
57
58static void node_layout(ui::Layout &layout, bContext * /*C*/, PointerRNA *ptr)
59{
60 layout.prop(ptr, "mode", UI_ITEM_NONE, "", ICON_NONE);
61}
62
63static void node_init(bNodeTree * /*tree*/, bNode *node)
64{
65 NodeCombSepColor *data = MEM_new<NodeCombSepColor>(__func__);
67 node->storage = data;
68}
69
70class SeparateRGBAFunction : public mf::MultiFunction {
71 public:
73 {
74 static const mf::Signature signature = []() {
75 mf::Signature signature;
76 mf::SignatureBuilder builder{"Separate Color", signature};
77 builder.single_input<ColorGeometry4f>("Color");
78 builder.single_output<float>("Red", mf::ParamFlag::SupportsUnusedOutput);
79 builder.single_output<float>("Green", mf::ParamFlag::SupportsUnusedOutput);
80 builder.single_output<float>("Blue", mf::ParamFlag::SupportsUnusedOutput);
81 builder.single_output<float>("Alpha", mf::ParamFlag::SupportsUnusedOutput);
82 return signature;
83 }();
85 }
86
87 void call(const IndexMask &mask, mf::Params params, mf::Context /*context*/) const override
88 {
89 const VArray<ColorGeometry4f> &colors = params.readonly_single_input<ColorGeometry4f>(0,
90 "Color");
91
92 MutableSpan<float> red = params.uninitialized_single_output_if_required<float>(1, "Red");
93 MutableSpan<float> green = params.uninitialized_single_output_if_required<float>(2, "Green");
94 MutableSpan<float> blue = params.uninitialized_single_output_if_required<float>(3, "Blue");
95 MutableSpan<float> alpha = params.uninitialized_single_output_if_required<float>(4, "Alpha");
96
97 std::array<MutableSpan<float>, 4> outputs = {red, green, blue, alpha};
98 Vector<int> used_outputs;
99 if (!red.is_empty()) {
100 used_outputs.append(0);
101 }
102 if (!green.is_empty()) {
103 used_outputs.append(1);
104 }
105 if (!blue.is_empty()) {
106 used_outputs.append(2);
107 }
108 if (!alpha.is_empty()) {
109 used_outputs.append(3);
110 }
111
112 devirtualize_varray(colors, [&](auto colors) {
113 mask.foreach_segment_optimized([&](const auto segment) {
114 const int used_outputs_num = used_outputs.size();
115 const int *used_outputs_data = used_outputs.data();
116
117 for (const int64_t i : segment) {
118 const ColorGeometry4f &color = colors[i];
119 for (const int out_i : IndexRange(used_outputs_num)) {
120 const int channel = used_outputs_data[out_i];
121 outputs[channel][i] = color[channel];
122 }
123 }
124 });
125 });
126 }
127};
128
129class SeparateHSVAFunction : public mf::MultiFunction {
130 public:
132 {
133 static const mf::Signature signature = []() {
134 mf::Signature signature;
135 mf::SignatureBuilder builder{"Separate Color", signature};
136 builder.single_input<ColorGeometry4f>("Color");
137 builder.single_output<float>("Hue");
138 builder.single_output<float>("Saturation");
139 builder.single_output<float>("Value");
140 builder.single_output<float>("Alpha", mf::ParamFlag::SupportsUnusedOutput);
141 return signature;
142 }();
143 this->set_signature(&signature);
144 }
145
146 void call(const IndexMask &mask, mf::Params params, mf::Context /*context*/) const override
147 {
148 const VArray<ColorGeometry4f> &colors = params.readonly_single_input<ColorGeometry4f>(0,
149 "Color");
150 MutableSpan<float> hue = params.uninitialized_single_output<float>(1, "Hue");
151 MutableSpan<float> saturation = params.uninitialized_single_output<float>(2, "Saturation");
152 MutableSpan<float> value = params.uninitialized_single_output<float>(3, "Value");
153 MutableSpan<float> alpha = params.uninitialized_single_output_if_required<float>(4, "Alpha");
154
155 mask.foreach_index_optimized<int64_t>([&](const int64_t i) {
156 rgb_to_hsv(colors[i].r, colors[i].g, colors[i].b, &hue[i], &saturation[i], &value[i]);
157 });
158
159 if (!alpha.is_empty()) {
160 mask.foreach_index_optimized<int64_t>([&](const int64_t i) { alpha[i] = colors[i].a; });
161 }
162 }
163};
164
165class SeparateHSLAFunction : public mf::MultiFunction {
166 public:
168 {
169 static const mf::Signature signature = []() {
170 mf::Signature signature;
171 mf::SignatureBuilder builder{"Separate Color", signature};
172 builder.single_input<ColorGeometry4f>("Color");
173 builder.single_output<float>("Hue");
174 builder.single_output<float>("Saturation");
175 builder.single_output<float>("Lightness");
176 builder.single_output<float>("Alpha", mf::ParamFlag::SupportsUnusedOutput);
177 return signature;
178 }();
179 this->set_signature(&signature);
180 }
181
182 void call(const IndexMask &mask, mf::Params params, mf::Context /*context*/) const override
183 {
184 const VArray<ColorGeometry4f> &colors = params.readonly_single_input<ColorGeometry4f>(0,
185 "Color");
186 MutableSpan<float> hue = params.uninitialized_single_output<float>(1, "Hue");
187 MutableSpan<float> saturation = params.uninitialized_single_output<float>(2, "Saturation");
188 MutableSpan<float> lightness = params.uninitialized_single_output<float>(3, "Lightness");
189 MutableSpan<float> alpha = params.uninitialized_single_output_if_required<float>(4, "Alpha");
190
191 mask.foreach_index_optimized<int64_t>([&](const int64_t i) {
192 rgb_to_hsl(colors[i].r, colors[i].g, colors[i].b, &hue[i], &saturation[i], &lightness[i]);
193 });
194
195 if (!alpha.is_empty()) {
196 mask.foreach_index_optimized<int64_t>([&](const int64_t i) { alpha[i] = colors[i].a; });
197 }
198 }
199};
200
202{
203 const NodeCombSepColor &storage = node_storage(builder.node());
204
205 switch (storage.mode) {
208 builder.set_matching_fn(fn);
209 break;
210 }
213 builder.set_matching_fn(fn);
214 break;
215 }
218 builder.set_matching_fn(fn);
219 break;
220 }
221 default: {
223 break;
224 }
225 }
226}
227
228static void node_rna(StructRNA *srna)
229{
231 "mode",
232 "Mode",
233 "Mode of color processing",
236}
237
238static void node_register()
239{
240 static bke::bNodeType ntype;
241
242 fn_node_type_base(&ntype, "FunctionNodeSeparateColor"_ustr, FN_NODE_SEPARATE_COLOR);
243 ntype.ui_name = "Separate Color";
244 ntype.ui_description = "Split a color into separate channels, based on a particular color model";
245 ntype.enum_name_legacy = "SEPARATE_COLOR";
247 ntype.declare = node_declare;
248 ntype.initfunc = node_init;
250 ntype, "NodeCombSepColor", node_free_standard_storage, node_copy_standard_storage);
253
255
256 node_rna(ntype.rna_ext.srna);
257}
259
260} // namespace blender::nodes::node_fn_separate_color_cc
#define NODE_CLASS_CONVERTER
Definition BKE_node.hh:484
#define NODE_STORAGE_FUNCS(StorageT)
Definition BKE_node.hh:1353
#define FN_NODE_SEPARATE_COLOR
#define CTX_IFACE_(context, msgid)
#define IFACE_(msgid)
#define BLT_I18NCONTEXT_COLOR
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define NOD_storage_enum_accessors(member)
#define UI_ITEM_NONE
#define BLI_assert_unreachable()
constexpr IndexRange()=default
int64_t size() const
void append(const T &value)
void set_signature(const Signature *signature)
void set_matching_fn(const mf::MultiFunction *fn)
std::unique_ptr< CustomSocketLabelFn > label_fn
void call(const IndexMask &mask, mf::Params params, mf::Context) const override
void call(const IndexMask &mask, mf::Params params, mf::Context) const override
void call(const IndexMask &mask, mf::Params params, mf::Context) const override
#define storage(slot, qualifiers)
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
static void node_layout(ui::Layout &layout, bContext *, PointerRNA *ptr)
static void node_build_multi_function(NodeMultiFunctionBuilder &builder)
static void node_init(bNodeTree *, bNode *node)
static void node_declare(NodeDeclarationBuilder &b)
PropertyRNA * RNA_def_node_enum(StructRNA *srna, const char *identifier, const char *ui_name, const char *ui_description, const EnumPropertyItem *static_items, const EnumRNAAccessors accessors, std::optional< int > default_value, const EnumPropertyItemFunc item_func, const bool allow_animation)
__int64 int64_t
Definition BKE_text.h:90
void devirtualize_varray(const VArray< T > &varray, const Func &func, bool enable=true)
void rgb_to_hsl(float r, float g, float b, float *r_h, float *r_s, float *r_l)
void rgb_to_hsv(float r, float g, float b, float *r_h, float *r_s, float *r_v)
@ NODE_COMBSEP_COLOR_HSL
@ NODE_COMBSEP_COLOR_HSV
@ NODE_COMBSEP_COLOR_RGB
BMesh const char void * data
void fn_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
void node_copy_standard_storage(bNodeTree *, bNode *dest_node, const bNode *src_node)
Definition node_util.cc:57
ColorSceneLinear4f< eAlpha::Premultiplied > ColorGeometry4f
void node_free_standard_storage(bNode *node)
Definition node_util.cc:45
const EnumPropertyItem rna_enum_node_combsep_color_items[]
Defines a node type.
Definition BKE_node.hh:265
void(*) draw_buttons(ui::Layout &, bContext *C, PointerRNA *ptr)
Definition BKE_node.hh:290
std::string ui_description
Definition BKE_node.hh:271
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
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)