COM_NodeOperation.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2011 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include <functional>
#include <list>
 
#include "BLI_ghash.h"
#include "BLI_hash.hh"
#include "BLI_math_base.hh"
#include "BLI_rect.h"
#include "BLI_span.hh"
#include "BLI_threads.h"
#include "BLI_utildefines.h"
 
#include "COM_Enums.h"
#include "COM_MemoryBuffer.h"
#include "COM_MetaData.h"
 
#include "BKE_node.hh"
#include "BKE_node_runtime.hh"
 
#include "DNA_node_types.h"
 
namespace blender::compositor {
 
class ExecutionSystem;
class NodeOperation;
class NodeOperationOutput;
 
typedef NodeOperation SocketReader;
 
static constexpr unsigned int RESOLUTION_INPUT_ANY = 999999;
 
enum class ResizeMode {
  Center = NS_CR_CENTER,
  None = NS_CR_NONE,
  Align = 100,
  FitWidth = NS_CR_FIT_WIDTH,
  FitHeight = NS_CR_FIT_HEIGHT,
  FitAny = NS_CR_FIT,
  Stretch = NS_CR_STRETCH,
};
 
class NodeOperationInput {
 private:
  NodeOperation *operation_;
 
  DataType datatype_;
 
  ResizeMode resize_mode_;
 
  NodeOperationOutput *link_;
 
 public:
  NodeOperationInput(NodeOperation *op,
                     DataType datatype,
                     ResizeMode resize_mode = ResizeMode::Center);
 
  NodeOperation &get_operation() const
  {
    return *operation_;
  }
  DataType get_data_type() const
  {
    return datatype_;
  }
 
  void set_link(NodeOperationOutput *link)
  {
    link_ = link;
  }
  NodeOperationOutput *get_link() const
  {
    return link_;
  }
  bool is_connected() const
  {
    return link_;
  }
 
  void set_resize_mode(ResizeMode resize_mode)
  {
    resize_mode_ = resize_mode;
  }
  ResizeMode get_resize_mode() const
  {
    return resize_mode_;
  }
 
  SocketReader *get_reader();
 
  bool determine_canvas(const rcti &preferred_area, rcti &r_area);
 
#ifdef WITH_CXX_GUARDEDALLOC
  MEM_CXX_CLASS_ALLOC_FUNCS("COM:NodeOperation")
#endif
};
 
class NodeOperationOutput {
 private:
  NodeOperation *operation_;
 
  DataType datatype_;
 
 public:
  NodeOperationOutput(NodeOperation *op, DataType datatype);
 
  NodeOperation &get_operation() const
  {
    return *operation_;
  }
  DataType get_data_type() const
  {
    return datatype_;
  }
 
  void determine_canvas(const rcti &preferred_area, rcti &r_area);
 
#ifdef WITH_CXX_GUARDEDALLOC
  MEM_CXX_CLASS_ALLOC_FUNCS("COM:NodeOperation")
#endif
};
 
struct NodeOperationFlags {
  bool use_render_border : 1;
  bool use_viewer_border : 1;
 
  bool is_canvas_set : 1;
 
  bool is_proxy_operation : 1;
  bool is_viewer_operation : 1;
  bool is_preview_operation : 1;
 
  bool use_datatype_conversion : 1;
 
  bool is_constant_operation : 1;
 
  bool can_be_constant : 1;
 
  NodeOperationFlags()
  {
    use_render_border = false;
    use_viewer_border = false;
    is_canvas_set = false;
    is_proxy_operation = false;
    is_viewer_operation = false;
    is_preview_operation = false;
    use_datatype_conversion = true;
    is_constant_operation = false;
    can_be_constant = false;
  }
};
 
struct NodeOperationHash {
 private:
  NodeOperation *operation_;
  size_t type_hash_;
  size_t parents_hash_;
  size_t params_hash_;
 
  friend class NodeOperation;
 
 public:
  NodeOperation *get_operation() const
  {
    return operation_;
  }
 
  bool operator==(const NodeOperationHash &other) const
  {
    return type_hash_ == other.type_hash_ && parents_hash_ == other.parents_hash_ &&
           params_hash_ == other.params_hash_;
  }
 
  bool operator!=(const NodeOperationHash &other) const
  {
    return !(*this == other);
  }
 
  bool operator<(const NodeOperationHash &other) const
  {
    return type_hash_ < other.type_hash_ ||
           (type_hash_ == other.type_hash_ && parents_hash_ < other.parents_hash_) ||
           (type_hash_ == other.type_hash_ && parents_hash_ == other.parents_hash_ &&
            params_hash_ < other.params_hash_);
  }
};
 
class NodeOperation {
 private:
  int id_;
  std::string name_;
  bNodeInstanceKey node_instance_key_{bke::NODE_INSTANCE_KEY_NONE};
 
  Vector<NodeOperationInput> inputs_;
  Vector<NodeOperationOutput> outputs_;
 
  size_t params_hash_;
  bool is_hash_output_params_implemented_;
 
  unsigned int canvas_input_index_;
 
  std::function<void(rcti &canvas)> modify_determined_canvas_fn_;
 
  const bNodeTree *btree_;
 
 protected:
  rcti canvas_ = COM_AREA_NONE;
 
  NodeOperationFlags flags_;
 
  ExecutionSystem *exec_system_;
 
 public:
  virtual ~NodeOperation() {}
 
  void set_name(const std::string name)
  {
    name_ = name;
  }
 
  const std::string get_name() const
  {
    return name_;
  }
 
  void set_id(const int id)
  {
    id_ = id;
  }
 
  const int get_id() const
  {
    return id_;
  }
 
  const void set_node_instance_key(const bNodeInstanceKey &node_instance_key)
  {
    node_instance_key_ = node_instance_key;
  }
  const bNodeInstanceKey get_node_instance_key() const
  {
    return node_instance_key_;
  }
 
  float get_constant_value_default(float default_value);
  const float *get_constant_elem_default(const float *default_elem);
 
  const NodeOperationFlags get_flags() const
  {
    return flags_;
  }
 
  std::optional<NodeOperationHash> generate_hash();
 
  unsigned int get_number_of_input_sockets() const
  {
    return inputs_.size();
  }
  unsigned int get_number_of_output_sockets() const
  {
    return outputs_.size();
  }
  NodeOperationOutput *get_output_socket(unsigned int index = 0);
  NodeOperationInput *get_input_socket(unsigned int index);
 
  NodeOperation *get_input_operation(int index);
 
  virtual void determine_canvas(const rcti &preferred_area, rcti &r_area);
 
  virtual bool is_output_operation(bool /*rendering*/) const
  {
    return false;
  }
 
  void set_bnodetree(const bNodeTree *tree)
  {
    btree_ = tree;
  }
 
  void set_execution_system(ExecutionSystem *system)
  {
    exec_system_ = system;
  }
 
  virtual void init_data();
 
  virtual void init_execution();
 
  virtual void deinit_execution();
 
  void set_canvas(const rcti &canvas_area);
  const rcti &get_canvas() const;
  void unset_canvas();
 
  virtual bool is_active_viewer_output() const
  {
    return false;
  }
 
  void set_canvas_input_index(unsigned int index);
 
  void set_determined_canvas_modifier(std::function<void(rcti &canvas)> fn)
  {
    modify_determined_canvas_fn_ = fn;
  }
 
  virtual eCompositorPriority get_render_priority() const
  {
    return eCompositorPriority::Low;
  }
 
  inline bool is_braked() const
  {
    return btree_->runtime->test_break(btree_->runtime->tbh);
  }
 
  inline void update_draw()
  {
    if (btree_->runtime->update_draw) {
      btree_->runtime->update_draw(btree_->runtime->udh);
    }
  }
 
  unsigned int get_width() const
  {
    return BLI_rcti_size_x(&get_canvas());
  }
 
  unsigned int get_height() const
  {
    return BLI_rcti_size_y(&get_canvas());
  }
 
  virtual MemoryBuffer *get_input_memory_buffer(MemoryBuffer ** /*memory_buffers*/)
  {
    return 0;
  }
 
  virtual std::unique_ptr<MetaData> get_meta_data()
  {
    return std::unique_ptr<MetaData>();
  }
 
  /* -------------------------------------------------------------------- */
  void render(MemoryBuffer *output_buf, Span<rcti> areas, Span<MemoryBuffer *> inputs_bufs);
 
  virtual void update_memory_buffer(MemoryBuffer * /*output*/,
                                    const rcti & /*area*/,
                                    Span<MemoryBuffer *> /*inputs*/)
  {
  }
 
  virtual void get_area_of_interest(int input_idx, const rcti &output_area, rcti &r_input_area);
  void get_area_of_interest(NodeOperation *input_op, const rcti &output_area, rcti &r_input_area);
 
 protected:
  NodeOperation();
 
  /* Overridden by subclasses to allow merging equal operations on compiling. Implementations must
   * hash any subclass parameter that affects the output result using `hash_params` methods. */
  virtual void hash_output_params()
  {
    is_hash_output_params_implemented_ = false;
  }
 
  static void combine_hashes(size_t &combined, size_t other)
  {
    combined = BLI_ghashutil_combine_hash(combined, other);
  }
 
  template<typename T> void hash_param(T param)
  {
    combine_hashes(params_hash_, get_default_hash(param));
  }
 
  template<typename T1, typename T2> void hash_params(T1 param1, T2 param2)
  {
    combine_hashes(params_hash_, get_default_hash(param1, param2));
  }
 
  template<typename T1, typename T2, typename T3> void hash_params(T1 param1, T2 param2, T3 param3)
  {
    combine_hashes(params_hash_, get_default_hash(param1, param2, param3));
  }
 
  void add_input_socket(DataType datatype, ResizeMode resize_mode = ResizeMode::Center);
  void add_output_socket(DataType datatype);
 
  SocketReader *get_input_socket_reader(unsigned int index);
 
 private:
  void render_full_frame(MemoryBuffer *output_buf,
                         Span<rcti> areas,
                         Span<MemoryBuffer *> inputs_bufs);
 
  /* allow the DebugInfo class to look at internals */
  friend class DebugInfo;
 
#ifdef WITH_CXX_GUARDEDALLOC
  MEM_CXX_CLASS_ALLOC_FUNCS("COM:NodeOperation")
#endif
};
 
std::ostream &operator<<(std::ostream &os, const NodeOperationFlags &node_operation_flags);
std::ostream &operator<<(std::ostream &os, const NodeOperation &node_operation);
 
}  // namespace blender::compositor