Blender V5.3
node_fn_separate_matrix.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
7
8#include "GPU_material.hh"
9
10#include "node_function_util.hh"
11
13
15{
16 b.is_function_node();
17 b.use_custom_socket_order();
18 b.allow_any_socket_order();
19
20 PanelDeclarationBuilder &column_a = b.add_panel("Column 1"_ustr).default_closed(true);
21 column_a.add_output<decl::Float>("Column 1 Row 1"_ustr);
22 column_a.add_output<decl::Float>("Column 1 Row 2"_ustr);
23 column_a.add_output<decl::Float>("Column 1 Row 3"_ustr);
24 column_a.add_output<decl::Float>("Column 1 Row 4"_ustr);
25
26 PanelDeclarationBuilder &column_b = b.add_panel("Column 2"_ustr).default_closed(true);
27 column_b.add_output<decl::Float>("Column 2 Row 1"_ustr);
28 column_b.add_output<decl::Float>("Column 2 Row 2"_ustr);
29 column_b.add_output<decl::Float>("Column 2 Row 3"_ustr);
30 column_b.add_output<decl::Float>("Column 2 Row 4"_ustr);
31
32 PanelDeclarationBuilder &column_c = b.add_panel("Column 3"_ustr).default_closed(true);
33 column_c.add_output<decl::Float>("Column 3 Row 1"_ustr);
34 column_c.add_output<decl::Float>("Column 3 Row 2"_ustr);
35 column_c.add_output<decl::Float>("Column 3 Row 3"_ustr);
36 column_c.add_output<decl::Float>("Column 3 Row 4"_ustr);
37
38 PanelDeclarationBuilder &column_d = b.add_panel("Column 4"_ustr).default_closed(true);
39 column_d.add_output<decl::Float>("Column 4 Row 1"_ustr);
40 column_d.add_output<decl::Float>("Column 4 Row 2"_ustr);
41 column_d.add_output<decl::Float>("Column 4 Row 3"_ustr);
42 column_d.add_output<decl::Float>("Column 4 Row 4"_ustr);
43
44 b.add_input<decl::Matrix>("Matrix"_ustr);
45}
46
47static void copy_with_stride(const IndexMask &mask,
48 const Span<float> src,
49 const int64_t src_step,
50 const int64_t src_begin,
51 const int64_t dst_step,
52 const int64_t dst_begin,
54{
55 if (dst.is_empty()) {
56 return;
57 }
58 BLI_assert(src_begin < src_step);
59 BLI_assert(dst_begin < dst_step);
60 mask.foreach_index_optimized<int>([&](const int64_t index) {
61 dst[dst_begin + dst_step * index] = src[src_begin + src_step * index];
62 });
63}
64
65class SeparateMatrixFunction : public mf::MultiFunction {
66 public:
68 {
69 static const mf::Signature signature = []() {
70 mf::Signature signature;
71 mf::SignatureBuilder builder{"Separate Matrix", signature};
72 builder.single_input<float4x4>("Matrix");
73
74 builder.single_output<float>("Column 1 Row 1", mf::ParamFlag::SupportsUnusedOutput);
75 builder.single_output<float>("Column 1 Row 2", mf::ParamFlag::SupportsUnusedOutput);
76 builder.single_output<float>("Column 1 Row 3", mf::ParamFlag::SupportsUnusedOutput);
77 builder.single_output<float>("Column 1 Row 4", mf::ParamFlag::SupportsUnusedOutput);
78
79 builder.single_output<float>("Column 2 Row 1", mf::ParamFlag::SupportsUnusedOutput);
80 builder.single_output<float>("Column 2 Row 2", mf::ParamFlag::SupportsUnusedOutput);
81 builder.single_output<float>("Column 2 Row 3", mf::ParamFlag::SupportsUnusedOutput);
82 builder.single_output<float>("Column 2 Row 4", mf::ParamFlag::SupportsUnusedOutput);
83
84 builder.single_output<float>("Column 3 Row 1", mf::ParamFlag::SupportsUnusedOutput);
85 builder.single_output<float>("Column 3 Row 2", mf::ParamFlag::SupportsUnusedOutput);
86 builder.single_output<float>("Column 3 Row 3", mf::ParamFlag::SupportsUnusedOutput);
87 builder.single_output<float>("Column 3 Row 4", mf::ParamFlag::SupportsUnusedOutput);
88
89 builder.single_output<float>("Column 4 Row 1", mf::ParamFlag::SupportsUnusedOutput);
90 builder.single_output<float>("Column 4 Row 2", mf::ParamFlag::SupportsUnusedOutput);
91 builder.single_output<float>("Column 4 Row 3", mf::ParamFlag::SupportsUnusedOutput);
92 builder.single_output<float>("Column 4 Row 4", mf::ParamFlag::SupportsUnusedOutput);
93 return signature;
94 }();
96 }
97
98 void call(const IndexMask &mask, mf::Params params, mf::Context /*context*/) const override
99 {
100 const VArray<float4x4> matrices = params.readonly_single_input<float4x4>(0, "Matrix");
101
102 MutableSpan<float> column_1_row_1 = params.uninitialized_single_output_if_required<float>(
103 1, "Column 1 Row 1");
104 MutableSpan<float> column_1_row_2 = params.uninitialized_single_output_if_required<float>(
105 2, "Column 1 Row 2");
106 MutableSpan<float> column_1_row_3 = params.uninitialized_single_output_if_required<float>(
107 3, "Column 1 Row 3");
108 MutableSpan<float> column_1_row_4 = params.uninitialized_single_output_if_required<float>(
109 4, "Column 1 Row 4");
110
111 MutableSpan<float> column_2_row_1 = params.uninitialized_single_output_if_required<float>(
112 5, "Column 2 Row 1");
113 MutableSpan<float> column_2_row_2 = params.uninitialized_single_output_if_required<float>(
114 6, "Column 2 Row 2");
115 MutableSpan<float> column_2_row_3 = params.uninitialized_single_output_if_required<float>(
116 7, "Column 2 Row 3");
117 MutableSpan<float> column_2_row_4 = params.uninitialized_single_output_if_required<float>(
118 8, "Column 2 Row 4");
119
120 MutableSpan<float> column_3_row_1 = params.uninitialized_single_output_if_required<float>(
121 9, "Column 3 Row 1");
122 MutableSpan<float> column_3_row_2 = params.uninitialized_single_output_if_required<float>(
123 10, "Column 3 Row 2");
124 MutableSpan<float> column_3_row_3 = params.uninitialized_single_output_if_required<float>(
125 11, "Column 3 Row 3");
126 MutableSpan<float> column_3_row_4 = params.uninitialized_single_output_if_required<float>(
127 12, "Column 3 Row 4");
128
129 MutableSpan<float> column_4_row_1 = params.uninitialized_single_output_if_required<float>(
130 13, "Column 4 Row 1");
131 MutableSpan<float> column_4_row_2 = params.uninitialized_single_output_if_required<float>(
132 14, "Column 4 Row 2");
133 MutableSpan<float> column_4_row_3 = params.uninitialized_single_output_if_required<float>(
134 15, "Column 4 Row 3");
135 MutableSpan<float> column_4_row_4 = params.uninitialized_single_output_if_required<float>(
136 16, "Column 4 Row 4");
137
138 if (const std::optional<float4x4> single = matrices.get_if_single()) {
139 const float4x4 &matrix = *single;
140 auto fill_value = [&](const MutableSpan<float> &r_values, const float value) {
141 /* If it's empty, the output is not used. */
142 if (!r_values.is_empty()) {
143 index_mask::masked_fill(r_values, value, mask);
144 }
145 };
146
147 fill_value(column_1_row_1, matrix[0][0]);
148 fill_value(column_1_row_2, matrix[0][1]);
149 fill_value(column_1_row_3, matrix[0][2]);
150 fill_value(column_1_row_4, matrix[0][3]);
151
152 fill_value(column_2_row_1, matrix[1][0]);
153 fill_value(column_2_row_2, matrix[1][1]);
154 fill_value(column_2_row_3, matrix[1][2]);
155 fill_value(column_2_row_4, matrix[1][3]);
156
157 fill_value(column_3_row_1, matrix[2][0]);
158 fill_value(column_3_row_2, matrix[2][1]);
159 fill_value(column_3_row_3, matrix[2][2]);
160 fill_value(column_3_row_4, matrix[2][3]);
161
162 fill_value(column_4_row_1, matrix[3][0]);
163 fill_value(column_4_row_2, matrix[3][1]);
164 fill_value(column_4_row_3, matrix[3][2]);
165 fill_value(column_4_row_4, matrix[3][3]);
166 return;
167 }
168
169 const VArraySpan<float4x4> span_matrices(matrices);
170 const Span<float> components = span_matrices.cast<float>();
171
172 copy_with_stride(mask, components, 16, 0, 1, 0, column_1_row_1);
173 copy_with_stride(mask, components, 16, 1, 1, 0, column_1_row_2);
174 copy_with_stride(mask, components, 16, 2, 1, 0, column_1_row_3);
175 copy_with_stride(mask, components, 16, 3, 1, 0, column_1_row_4);
176
177 copy_with_stride(mask, components, 16, 4, 1, 0, column_2_row_1);
178 copy_with_stride(mask, components, 16, 5, 1, 0, column_2_row_2);
179 copy_with_stride(mask, components, 16, 6, 1, 0, column_2_row_3);
180 copy_with_stride(mask, components, 16, 7, 1, 0, column_2_row_4);
181
182 copy_with_stride(mask, components, 16, 8, 1, 0, column_3_row_1);
183 copy_with_stride(mask, components, 16, 9, 1, 0, column_3_row_2);
184 copy_with_stride(mask, components, 16, 10, 1, 0, column_3_row_3);
185 copy_with_stride(mask, components, 16, 11, 1, 0, column_3_row_4);
186
187 copy_with_stride(mask, components, 16, 12, 1, 0, column_4_row_1);
188 copy_with_stride(mask, components, 16, 13, 1, 0, column_4_row_2);
189 copy_with_stride(mask, components, 16, 14, 1, 0, column_4_row_3);
190 copy_with_stride(mask, components, 16, 15, 1, 0, column_4_row_4);
191 }
192};
193
195{
196 const static SeparateMatrixFunction fn;
197 builder.set_matching_fn(fn);
198}
199
201{
202 using namespace value_elem;
203 const MatrixElem matrix_elem = params.get_input_elem<MatrixElem>("Matrix"_ustr);
204 std::array<std::array<FloatElem, 4>, 4> output_elems;
205
206 output_elems[3][0] = matrix_elem.translation.x;
207 output_elems[3][1] = matrix_elem.translation.y;
208 output_elems[3][2] = matrix_elem.translation.z;
209
210 if (matrix_elem.rotation || matrix_elem.scale) {
211 for (const int col : IndexRange(3)) {
212 for (const int row : IndexRange(3)) {
213 output_elems[col][row] = FloatElem::all();
214 }
215 }
216 }
217
218 if (matrix_elem.any_non_transform) {
219 for (const int col : IndexRange(4)) {
220 output_elems[col][3] = FloatElem::all();
221 }
222 }
223
224 for (const int col : IndexRange(4)) {
225 for (const int row : IndexRange(4)) {
226 const bNodeSocket &socket = params.node.output_socket(col * 4 + row);
227 params.set_output_elem(socket.identifier_ustr(), output_elems[col][row]);
228 }
229 }
230}
231
233{
234 using namespace value_elem;
235
236 std::array<std::array<FloatElem, 4>, 4> output_elems;
237 for (const int col : IndexRange(4)) {
238 for (const int row : IndexRange(4)) {
239 const bNodeSocket &socket = params.node.output_socket(col * 4 + row);
240 output_elems[col][row] = params.get_output_elem<FloatElem>(socket.identifier_ustr());
241 }
242 }
243
244 MatrixElem matrix_elem;
245 matrix_elem.translation.x = output_elems[3][0];
246 matrix_elem.translation.y = output_elems[3][1];
247 matrix_elem.translation.z = output_elems[3][2];
248
249 bool any_inner_3x3 = false;
250 for (const int col : IndexRange(3)) {
251 for (const int row : IndexRange(3)) {
252 any_inner_3x3 |= output_elems[col][row];
253 }
254 }
255
256 if (any_inner_3x3) {
257 matrix_elem.rotation = RotationElem::all();
258 matrix_elem.scale = VectorElem::all();
259 }
260
261 const bool any_non_transform = output_elems[0][3] || output_elems[1][3] || output_elems[2][3] ||
262 output_elems[3][3];
263 if (any_non_transform) {
264 matrix_elem.any_non_transform = FloatElem::all();
265 }
266
267 params.set_input_elem("Matrix"_ustr, matrix_elem);
268}
269
271{
272 float4x4 matrix;
273 for (const int col : IndexRange(4)) {
274 for (const int row : IndexRange(4)) {
275 const bNodeSocket &socket = params.node.output_socket(col * 4 + row);
276 matrix[col][row] = params.get_output<float>(socket.identifier_ustr());
277 }
278 }
279 params.set_input("Matrix"_ustr, matrix);
280}
281
282static int node_gpu_material(GPUMaterial *material,
283 bNode *node,
284 bNodeExecData * /*execdata*/,
285 GPUNodeStack *inputs,
286 GPUNodeStack *outputs)
287{
288 return GPU_stack_link(material, node, "node_function_separate_matrix", inputs, outputs);
289}
290
291static void node_register()
292{
293 static bke::bNodeType ntype;
294 fn_cmp_node_type_base(&ntype, "FunctionNodeSeparateMatrix"_ustr, FN_NODE_SEPARATE_MATRIX);
295 ntype.ui_name = "Separate Matrix";
296 ntype.ui_description = "Split a 4x4 matrix into its individual values";
297 ntype.enum_name_legacy = "SEPARATE_MATRIX";
299 ntype.declare = node_declare;
306}
308
309} // namespace blender::nodes::node_fn_separate_matrix_cc
#define NODE_CLASS_CONVERTER
Definition BKE_node.hh:484
#define FN_NODE_SEPARATE_MATRIX
#define NOD_REGISTER_NODE(REGISTER_FUNC)
constexpr IndexRange()=default
constexpr bool is_empty() const
Definition BLI_span.hh:515
std::optional< T > get_if_single() const
Span< NewT > constexpr cast() const
void set_signature(const Signature *signature)
DeclType::Builder & add_output(UString name, UString identifier=""_ustr)
void set_matching_fn(const mf::MultiFunction *fn)
void set_input(const UString identifier, T value)
void call(const IndexMask &mask, mf::Params params, mf::Context) const override
T get_input_elem(const UString identifier) const
void set_output_elem(const UString identifier, T elem)
void set_input_elem(const UString identifier, T elem)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
void masked_fill(MutableSpan< T > data, const T &value, const IndexMask &mask)
static void node_build_multi_function(NodeMultiFunctionBuilder &builder)
static void node_eval_inverse_elem(value_elem::InverseElemEvalParams &params)
static void node_eval_elem(value_elem::ElemEvalParams &params)
static void node_declare(NodeDeclarationBuilder &b)
static int node_gpu_material(GPUMaterial *material, bNode *node, bNodeExecData *, GPUNodeStack *inputs, GPUNodeStack *outputs)
static void copy_with_stride(const IndexMask &mask, const Span< float > src, const int64_t src_step, const int64_t src_begin, const int64_t dst_step, const int64_t dst_begin, MutableSpan< float > dst)
static void node_eval_inverse(inverse_eval::InverseEvalParams &params)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
bool GPU_stack_link(GPUMaterial *mat, const bNode *node, const char *name, GPUNodeStack *in, GPUNodeStack *out,...)
__int64 int64_t
Definition BKE_text.h:90
void fn_cmp_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
MatBase< float, 4, 4 > float4x4
Defines a node type.
Definition BKE_node.hh:265
NodeInverseElemEvalFunction eval_inverse_elem
Definition BKE_node.hh:434
NodeInverseEvalFunction eval_inverse
Definition BKE_node.hh:441
std::string ui_description
Definition BKE_node.hh:271
NodeGPUExecFunction gpu_fn
Definition BKE_node.hh:373
NodeElemEvalFunction eval_elem
Definition BKE_node.hh:428
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