48 operation_(operation),
49 compute_context_(compute_context)
55 this->compute_zone_external_input_reference_counts();
58 if (this->context().is_canceled()) {
59 this->cancel_evaluation();
63 if (this->should_compile_pixel_compile_unit(*
node)) {
64 this->evaluate_pixel_compile_unit();
68 this->add_node_to_pixel_compile_unit(*
node);
74 if (node_zone && node_zone != this->
schedule().zone) {
76 this->evaluate_zone(*node_zone);
80 this->evaluate_node(*
node);
95 if (pixel_operation) {
97 return pixel_operation->
get_result(identifier);
102 if (zone_operation) {
110 if (node_zone != this->
schedule().zone) {
120 return pixel_compile_unit_;
128void NodeTreeEvaluator::compute_zone_external_input_reference_counts()
149 result.set_reference_count(
result.reference_count() + reference_count);
162NodeOperation *NodeTreeEvaluator::create_node_operation(
const bNode &
node)
164 const char *disabled_hint =
nullptr;
165 if (!
node.typeinfo->poll(
node.typeinfo, &
node.owner_tree(), &disabled_hint)) {
169 if (
node.is_group()) {
181 return node.typeinfo->get_compositor_operation(this->context(),
node);
184void NodeTreeEvaluator::evaluate_node(
const bNode &
node)
186 NodeOperation *operation = this->create_node_operation(
node);
187 operation->set_compute_context(compute_context_);
189 node_operations_.add_new(&
node, operation);
191 this->map_node_operation_inputs_to_their_results(
node, operation);
193 operations_stream_.append(std::unique_ptr<Operation>(operation));
195 operation->compute_results_reference_counts(this->
schedule());
197 operation->evaluate();
200void NodeTreeEvaluator::map_unlinked_input(
const bNodeSocket &input,
Operation *operation)
203 if (!input_descriptor.implicit_input.has_value()) {
205 this->context(), input);
206 operations_stream_.append(std::unique_ptr<SingleValueNodeInputOperation>(input_operation));
207 input_operation->evaluate();
208 operation->map_input_to_result(input.identifier, &input_operation->get_result());
213 this->context(), input_descriptor.implicit_input.value());
214 operations_stream_.append(std::unique_ptr<ImplicitInputOperation>(input_operation));
215 input_operation->evaluate();
216 operation->map_input_to_result(input.identifier, &input_operation->get_result());
219void NodeTreeEvaluator::map_node_operation_inputs_to_their_results(
const bNode &
node,
222 for (
const bNodeSocket *input :
node.input_sockets()) {
228 if (!
output || this->
schedule().unneeded_inputs.contains(input) ||
231 this->map_unlinked_input(*input, operation);
236 operation->map_input_to_result(input->identifier, &
result);
244 const bool is_single_value = this->is_pixel_compile_unit_single_value();
245 if (!this->context().use_gpu() || is_single_value) {
247 this->context(), *
this, is_single_value, compute_context_);
253void NodeTreeEvaluator::evaluate_pixel_compile_unit()
258 const bool needs_node_previews = flag_is_set(this->context().needed_side_effect_output_types(),
265 if (compile_unit.size() > 1 &&
266 (this->pixel_compile_unit_has_too_many_outputs(needs_node_previews) ||
267 this->pixel_compile_unit_has_too_many_inputs()))
269 const int split_index = compile_unit.size() / 2;
270 const PixelCompileUnit start_compile_unit(compile_unit.as_span().take_front(split_index));
271 const PixelCompileUnit end_compile_unit(compile_unit.as_span().drop_front(split_index));
274 this->evaluate_pixel_compile_unit();
277 this->evaluate_pixel_compile_unit();
284 PixelOperation *operation = this->create_pixel_operation();
286 for (
const bNode *
node : compile_unit) {
287 pixel_operations_.add_new(
node, operation);
290 map_pixel_operation_inputs_to_their_results(operation);
292 operations_stream_.append(std::unique_ptr<Operation>(operation));
294 operation->compute_results_reference_counts(this->
schedule());
296 operation->evaluate();
298 this->reset_pixel_compile_unit();
301void NodeTreeEvaluator::map_pixel_operation_inputs_to_their_results(
PixelOperation *operation)
303 for (
const auto item : operation->get_inputs_to_linked_outputs_map().items()) {
304 const bNodeSocket &
output = *item.value;
305 const StringRef input_identifier = item.key;
308 operation->map_input_to_result(input_identifier, input_result);
313 const int internal_reference_count = operation->get_internal_input_reference_count(
315 input_result->decrement_reference_count(internal_reference_count - 1);
318 for (
const auto item : operation->get_implicit_inputs_to_input_identifiers_map().items()) {
321 operation->map_input_to_result(item.value, &input_operation->get_result());
323 operations_stream_.append(std::unique_ptr<ImplicitInputOperation>(input_operation));
325 input_operation->evaluate();
329ZoneOperation *NodeTreeEvaluator::create_zone_operation(
const bke::bNodeTreeZone &zone)
331 if (zone.output_node()->is_type(
"GeometryNodeRepeatOutput"_ustr)) {
332 return new RepeatZoneOperation(this->context(), zone, compute_context_);
334 if (zone.output_node()->is_type(
"NodeClosureOutput"_ustr)) {
335 return new ClosureZoneOperation(this->context(), zone, compute_context_);
342void NodeTreeEvaluator::evaluate_zone(
const bke::bNodeTreeZone &zone)
344 ZoneOperation *operation = this->create_zone_operation(zone);
346 zone_operations_.add_new(zone.output_node(), operation);
348 this->map_zone_operation_inputs_to_their_results(operation);
350 operations_stream_.append(std::unique_ptr<Operation>(operation));
352 operation->compute_results_reference_counts(this->
schedule());
354 operation->evaluate();
357void NodeTreeEvaluator::map_zone_operation_inputs_to_their_results(
ZoneOperation *operation)
359 for (
const bNodeSocket *input : operation->zone().input_node()->input_sockets()) {
365 if (!
output || this->
schedule().unneeded_inputs.contains(input)) {
366 this->map_unlinked_input(*input, operation);
371 operation->map_input_to_result(input->identifier, &input_result);
374 Set<const bNodeSocket *> outputs_already_considered;
375 for (
const bNodeLink *link : operation->zone().border_links) {
381 if (outputs_already_considered.contains(
output)) {
384 outputs_already_considered.add_new(
output);
388 operation->map_input_to_result(input_identifier, input_result);
392void NodeTreeEvaluator::add_node_to_pixel_compile_unit(
const bNode &
node)
398 const bool is_first_node_in_operation = pixel_compile_unit_.size() == 1;
399 if (is_first_node_in_operation) {
400 is_pixel_compile_unit_single_value_ = this->is_pixel_node_single_value(
node);
403 if (!is_pixel_compile_unit_single_value_) {
404 pixel_compile_unit_domain_ = this->compute_pixel_node_domain(
node);
409bool NodeTreeEvaluator::is_pixel_compile_unit_single_value()
411 return is_pixel_compile_unit_single_value_;
414void NodeTreeEvaluator::reset_pixel_compile_unit()
416 pixel_compile_unit_.clear();
417 pixel_compile_unit_domain_.reset();
420bool NodeTreeEvaluator::should_compile_pixel_compile_unit(
const bNode &
node)
423 if (pixel_compile_unit_.is_empty()) {
436 if (is_pixel_compile_unit_single_value_ != this->is_pixel_node_single_value(
node)) {
443 if (!is_pixel_compile_unit_single_value_) {
444 if (pixel_compile_unit_domain_.value() != this->compute_pixel_node_domain(
node)) {
454bool NodeTreeEvaluator::is_pixel_node_single_value(
const bNode &
node)
457 for (
const bNodeSocket *
output :
node.output_sockets()) {
468 for (
const bNodeSocket *input :
node.input_sockets()) {
479 for (
const bNodeSocket *input :
node.input_sockets()) {
488 if (!input_descriptor.implicit_input.has_value()) {
493 context_, input_descriptor.implicit_input.value());
494 if (!domain.has_value()) {
505 if (pixel_compile_unit_.contains(&
output->owner_node())) {
506 if (is_pixel_compile_unit_single_value_) {
513 if (!
result.is_single_value()) {
521Domain NodeTreeEvaluator::compute_pixel_node_domain(
const bNode &
node)
526 int current_domain_priority = std::numeric_limits<int>::max();
530 for (
const bNodeSocket *input :
node.input_sockets()) {
541 if (!input_descriptor.implicit_input.has_value()) {
546 context_, input_descriptor.implicit_input.value());
547 if (!domain.has_value()) {
556 if (input_descriptor.domain_priority < current_domain_priority) {
557 node_domain = domain.value();
558 current_domain_priority = input_descriptor.domain_priority;
565 if (pixel_compile_unit_.contains(&
output->owner_node())) {
568 if (input_descriptor.domain_priority < current_domain_priority) {
569 node_domain = pixel_compile_unit_domain_.value();
570 current_domain_priority = input_descriptor.domain_priority;
578 if (
result.is_single_value() || input_descriptor.expects_single_value) {
589 if (input_descriptor.domain_priority < current_domain_priority) {
590 node_domain =
result.domain();
591 current_domain_priority = input_descriptor.domain_priority;
598bool NodeTreeEvaluator::pixel_compile_unit_has_too_many_outputs(
599 const bool are_node_previews_needed)
602 if (!context_.use_gpu() || is_pixel_compile_unit_single_value_) {
606 int outputs_count = 0;
607 for (
const bNode *
node : pixel_compile_unit_) {
608 const bNodeSocket *preview_output = are_node_previews_needed ?
612 for (
const bNodeSocket *
output :
node->output_sockets()) {
618 const bool is_preview_output =
output == preview_output;
623 *
output, schedule_, &pixel_compile_unit_) != 0;
625 if (is_operation_output || is_preview_output) {
638bool NodeTreeEvaluator::pixel_compile_unit_has_too_many_inputs()
641 if (!context_.use_gpu() || is_pixel_compile_unit_single_value_) {
645 Set<ImplicitInputType> referenced_implicit_inputs;
646 Set<const bNodeSocket *> referenced_output_sockets;
647 int inputs_count = 0;
648 for (
const bNode *
node : pixel_compile_unit_) {
649 for (
const bNodeSocket *input :
node->input_sockets()) {
654 if (this->
schedule().unneeded_inputs.contains(input)) {
661 if (!input_descriptor.implicit_input.has_value()) {
667 if (referenced_implicit_inputs.contains(input_descriptor.implicit_input.value())) {
676 referenced_implicit_inputs.add_new(input_descriptor.implicit_input.value());
681 if (pixel_compile_unit_.contains(&
output->owner_node())) {
687 if (referenced_output_sockets.contains(
output)) {
693 if (
result.is_single_value()) {
702 referenced_output_sockets.add_new(
output);
709void NodeTreeEvaluator::cancel_evaluation()
711 for (
const std::unique_ptr<Operation> &operation : operations_stream_) {
712 operation->free_results();
716Context &NodeTreeEvaluator::context()
#define BLI_assert_unreachable()
bool contains(const Key &key) const
void add_new(const Key &key)
const bNode * output_node() const
const bNodeTreeZone * get_zone_by_node(const int32_t node_id) 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)
NodeTreeEvaluator(Context &context, const Schedule &schedule, Operation &operation, const ComputeContext &compute_context)
PixelCompileUnit & pixel_compile_unit()
const Schedule & schedule()
Result & get_result(StringRef identifier)
StringRef get_output_identifier_from_output_socket(const bNodeSocket &output_socket)
static bool is_single_value_only_type(ResultType type)
static const int maximum_outputs_count
static const int maximum_inputs_count
ShaderOperation(Context &context, NodeTreeEvaluator &node_tree_evaluator, const ComputeContext &compute_context)
static std::string get_external_input_identifier(const bNodeSocket &output)
Span< int > all_zone_output_node_types()
Span< int > all_zone_input_node_types()
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)
const bNodeSocket * get_output_linked_to_input(const bNodeSocket &input)
NodeOperation * get_node_tree_input_node_operation(Context &context, const bNode &node, Operation &operation)
NodeOperation * get_group_node_operation(Context &context, const bNode &node)
ResultType get_node_socket_result_type(const bNodeSocket *socket)
bool is_pixel_node(const bNode &node)
static bool is_node_tree_input_node(const bNode &node)
VectorSet< const bNode * > PixelCompileUnit
InputDescriptor input_descriptor_from_input_socket(const bNodeSocket *socket)
NodeOperation * get_undefined_node_operation(Context &context, const bNode &node)
bool is_socket_available(const bNodeSocket *socket)
NodeOperation * get_node_tree_output_node_operation(Context &context, const bNode &node, Operation &operation)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)