53 const bool is_single_value,
56 procedure_builder_(procedure_)
58 this->build_procedure();
59 procedure_executor_ = std::make_unique<mf::ProcedureExecutor>(procedure_);
67 mf::ParamsBuilder parameter_builder{*procedure_executor_, &
mask};
71 for (
int i = 0; i < procedure_.params().size(); i++) {
72 if (procedure_.params()[i].type == mf::ParamType::InterfaceType::Input) {
75 parameter_builder.add_readonly_single_input(input.
single_value());
81 parameter_builder.add_readonly_single_input(
85 parameter_builder.add_readonly_single_input(input.
cpu_data());
92 output.allocate_single_value();
93 parameter_builder.add_uninitialized_single_output(
97 output.allocate_texture(domain);
98 parameter_builder.add_uninitialized_single_output(
output.cpu_data_for_write());
103 mf::ContextBuilder context_builder;
104 procedure_executor_->call_auto(
mask, parameter_builder, context_builder);
107void MultiFunctionProcedureOperation::build_procedure()
111 auto &multi_function_builder = *node_multi_functions_.lookup_or_add_cb(
node, [&]() {
112 return std::make_unique<nodes::NodeMultiFunctionBuilder>(*
node,
node->owner_tree());
114 node->typeinfo->build_multi_function(multi_function_builder);
115 const mf::MultiFunction &multi_function = multi_function_builder.function();
127 this->assign_output_variables(*
node, output_variables);
131 for (
const auto &item : output_to_variable_map_.items()) {
133 if (!output_variables_.
contains(item.value)) {
134 procedure_builder_.add_destruct(*item.value);
137 for (mf::Variable *variable : implicit_variables_) {
139 if (!output_variables_.contains(variable)) {
140 procedure_builder_.add_destruct(*variable);
143 for (mf::Variable *variable : implicit_input_to_variable_map_.values()) {
144 procedure_builder_.add_destruct(*variable);
147 mf::ReturnInstruction &return_instruction = procedure_builder_.add_return();
148 procedure_.prepare_for_execution();
149 mf::procedure_optimization::move_destructs_up(procedure_, return_instruction);
154 const bNode &
node,
const mf::MultiFunction &multi_function)
156 int available_inputs_index = 0;
157 Vector<mf::Variable *> input_variables;
158 for (
const bNodeSocket *input :
node.input_sockets()) {
163 const mf::ParamType parameter_type = multi_function.param_type(available_inputs_index);
164 available_inputs_index++;
167 input_variables.append(this->get_default_value_variable(parameter_type.data_type()));
174 if (!input_descriptor.implicit_input.has_value()) {
176 input_variables.append(this->get_constant_input_variable(*input));
179 input_variables.append(this->get_implicit_input_variable(*input));
186 input_variables.append(output_to_variable_map_.lookup(
output));
191 input_variables.append(this->get_multi_function_input_variable(*input, *
output));
196 input_variables.last() = this->convert_variable(input_variables.last(),
197 parameter_type.data_type());
200 return input_variables;
203mf::Variable *MultiFunctionProcedureOperation::get_constant_input_variable(
204 const bNodeSocket &input)
206 const mf::MultiFunction *constant_function =
nullptr;
207 switch (input.type) {
209 const float value = input.default_value_typed<bNodeSocketValueFloat>()->value;
210 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<float>>(value);
214 const int value = input.default_value_typed<bNodeSocketValueInt>()->value;
215 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<int32_t>>(value);
219 const bool value = input.default_value_typed<bNodeSocketValueBoolean>()->value;
220 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<bool>>(value);
224 switch (input.default_value_typed<bNodeSocketValueVector>()->dimensions) {
226 const float2 value =
float2(input.default_value_typed<bNodeSocketValueVector>()->value);
227 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<float2>>(value);
231 const float3 value =
float3(input.default_value_typed<bNodeSocketValueVector>()->value);
232 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<float3>>(value);
236 const float4 value =
float4(input.default_value_typed<bNodeSocketValueVector>()->value);
237 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<float4>>(value);
247 switch (input.default_value_typed<bNodeSocketValueIntVector>()->dimensions) {
249 const int2 value =
int2(input.default_value_typed<bNodeSocketValueIntVector>()->value);
250 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<int2>>(value);
254 const int3 value =
int3(input.default_value_typed<bNodeSocketValueIntVector>()->value);
255 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<int3>>(value);
265 const Color value =
Color(input.default_value_typed<bNodeSocketValueRGBA>()->value);
266 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<float4>>(value);
271 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<float4x4>>(value);
275 const int32_t value = input.default_value_typed<bNodeSocketValueMenu>()->value;
276 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<nodes::MenuValue>>(
281 const std::string value = input.default_value_typed<bNodeSocketValueString>()->value;
282 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<std::string>>(
287 const bNodeSocketValueRotation *
rotation =
288 input.default_value_typed<bNodeSocketValueRotation>();
291 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<math::Quaternion>>(
296 Object *value = input.default_value_typed<bNodeSocketValueObject>()->value;
297 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<Object *>>(value);
301 Image *value = input.default_value_typed<bNodeSocketValueImage>()->value;
302 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<Image *>>(value);
306 VFont *value = input.default_value_typed<bNodeSocketValueFont>()->value;
307 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<VFont *>>(value);
311 Scene *value = input.default_value_typed<bNodeSocketValueScene>()->value;
312 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<Scene *>>(value);
316 Text *value = input.default_value_typed<bNodeSocketValueText>()->value;
317 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<Text *>>(value);
321 Mask *value = input.default_value_typed<bNodeSocketValueMask>()->value;
322 constant_function = &procedure_.construct_function<mf::CustomMF_Constant<Mask *>>(value);
335 mf::Variable *constant_variable = procedure_builder_.add_call<1>(*constant_function)[0];
336 implicit_variables_.
append(constant_variable);
337 return constant_variable;
340mf::Variable *MultiFunctionProcedureOperation::get_implicit_input_variable(
341 const bNodeSocket &input)
344 const ImplicitInputType implicit_input = input_descriptor.implicit_input.value();
348 if (implicit_input_to_variable_map_.contains(implicit_input)) {
355 existing_input_descriptor.domain_priority =
math::min(
356 existing_input_descriptor.domain_priority, input_descriptor.domain_priority);
358 return implicit_input_to_variable_map_.lookup(implicit_input);
362 const std::string input_identifier =
"implicit_input" + std::to_string(implicit_input_index);
368 mf::Variable &variable = procedure_builder_.add_input_parameter(
369 mf::DataType::ForSingle(
Result::cpp_type(input_descriptor.type)), input_identifier);
370 parameter_identifiers_.append(input_identifier);
373 implicit_input_to_variable_map_.add(implicit_input, &variable);
378mf::Variable *MultiFunctionProcedureOperation::get_multi_function_input_variable(
379 const bNodeSocket &input_socket,
const bNodeSocket &output_socket)
385 if (
result.is_single_value()) {
386 const mf::MultiFunction &constant_function =
387 procedure_.construct_function<mf::CustomMF_GenericConstant>(
388 *
result.single_value().type(),
result.single_value().get(),
true);
389 mf::Variable *constant_variable = procedure_builder_.add_call<1>(constant_function)[0];
390 implicit_variables_.append(constant_variable);
392 return constant_variable;
397 if (output_to_variable_map_.contains(&output_socket)) {
404 input_descriptor.domain_priority =
math::min(
405 input_descriptor.domain_priority,
411 return output_to_variable_map_.lookup(&output_socket);
415 const std::string input_identifier =
"input" + std::to_string(input_index);
421 input_descriptor.type =
result.type();
424 mf::Variable &variable = procedure_builder_.add_input_parameter(
425 mf::DataType::ForSingle(
Result::cpp_type(input_descriptor.type)), input_identifier);
426 parameter_identifiers_.append(input_identifier);
429 output_to_variable_map_.add(&output_socket, &variable);
444void MultiFunctionProcedureOperation::assign_output_variables(
const bNode &
node,
451 const bool needs_node_previews = flag_is_set(this->
context().needed_side_effect_output_types(),
453 const bNodeSocket *preview_output =
nullptr;
458 int available_outputs_index = 0;
459 for (
const bNodeSocket *
output :
node.output_sockets()) {
464 mf::Variable *output_variable = variables[available_outputs_index];
465 output_to_variable_map_.add_new(
output, output_variable);
476 const bool is_preview_output =
output == preview_output;
477 if (is_preview_output) {
481 if (should_log_outputs) {
485 if (is_operation_output || is_preview_output || should_log_outputs) {
486 this->populate_operation_result(*
output, output_variable);
489 available_outputs_index++;
493void MultiFunctionProcedureOperation::populate_operation_result(
const bNodeSocket &output_socket,
494 mf::Variable *variable)
497 const std::string output_identifier =
"output" + std::to_string(output_id);
506 const mf::DataType expected_type = mf::DataType::ForSingle(
Result::cpp_type(result_type));
507 mf::Variable *converted_variable = this->convert_variable(variable, expected_type);
509 procedure_builder_.add_output_parameter(*converted_variable);
510 output_variables_.add_new(converted_variable);
511 parameter_identifiers_.append(output_identifier);
514mf::Variable *MultiFunctionProcedureOperation::convert_variable(mf::Variable *variable,
515 const mf::DataType expected_type)
518 const mf::DataType variable_type = variable->data_type();
519 if (variable_type == expected_type) {
524 const mf::MultiFunction *function = conversion_table.get_conversion_multi_function(
525 variable_type, expected_type);
529 return this->get_default_value_variable(expected_type);
532 mf::Variable *converted_variable = procedure_builder_.add_call<1>(*function, {variable})[0];
533 implicit_variables_.append(converted_variable);
534 return converted_variable;
537mf::Variable *MultiFunctionProcedureOperation::get_default_value_variable(
const mf::DataType type)
539 const mf::MultiFunction &constant_function =
540 procedure_.construct_function<mf::CustomMF_GenericConstant>(
541 type.single_type(), type.single_type().default_value(),
false);
542 mf::Variable *constant_variable = procedure_builder_.add_call<1>(constant_function)[0];
543 implicit_variables_.append(constant_variable);
544 return constant_variable;
#define BLI_assert_unreachable()
const void * default_value() const
const Value & lookup(const Key &key) const
void add_new(const Key &key, const Value &value)
bool contains(const Key &key) const
bool contains(const Key &key) const
void append(const T &value)
virtual nodes::eval_log::NodesEvalLog * nodes_evaluation_log() const
MultiFunctionProcedureOperation(Context &context, NodeTreeEvaluator &node_tree_evaluator, const bool is_single_value, const ComputeContext &compute_context)
Result & get_result_from_output_socket(const bNodeSocket &output)
PixelCompileUnit & pixel_compile_unit()
const Schedule & schedule()
Result & get_result(StringRef identifier)
void populate_result(StringRef identifier, ResultType type)
Context & context() const
Result & get_input(StringRef identifier) const
virtual Domain compute_domain()
InputDescriptor & get_input_descriptor(StringRef identifier)
void declare_input_descriptor(StringRef identifier, InputDescriptor descriptor)
Map< ImplicitInputType, std::string > implicit_inputs_to_input_identifiers_map_
VectorSet< const bNodeSocket * > preview_outputs_
Map< std::string, const bNodeSocket * > inputs_to_linked_outputs_map_
NodeTreeEvaluator & node_tree_evaluator_
Map< const bNodeSocket *, std::string > output_sockets_to_output_identifiers_map_
VectorSet< const bNodeSocket * > logged_outputs_
Map< std::string, int > inputs_to_reference_counts_map_
PixelOperation(Context &context, NodeTreeEvaluator &node_tree_evaluator, const ComputeContext &compute_context, const bool is_single_value)
const bool is_single_value_
Map< const bNodeSocket *, std::string > outputs_to_declared_inputs_map_
bool is_single_value() const
const CPPType & get_cpp_type() const
GPointer single_value() const
static const CPPType & cpp_type(const ResultType type)
const DataTypeConversions & get_implicit_type_conversions()
int compute_output_reference_count(const bNodeSocket &output, const Schedule &schedule, const VectorSet< const bNode * > *ignored_nodes=nullptr)
const bNodeSocket * find_preview_output_socket(const bNode &node)
bool is_node_preview_needed(const bNode &node)
const bNodeSocket * get_output_linked_to_input(const bNodeSocket &input)
ColorSceneLinear4f< eAlpha::Premultiplied > Color
ResultType get_node_socket_result_type(const bNodeSocket *socket)
InputDescriptor input_descriptor_from_input_socket(const bNodeSocket *socket)
bool is_socket_available(const bNodeSocket *socket)
QuaternionBase< float > Quaternion
QuaternionBase< T > to_quaternion(const AxisAngleBase< T, AngleT > &axis_angle)
EulerXYZBase< float > EulerXYZ
T min(const T &a, const T &b)
constexpr StringRefNull rotation
static MatBase identity()
Set< const bNodeSocket * > unneeded_inputs