COM_Node.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2011 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BLI_vector.hh"
 
#include "DNA_node_types.h"
 
/* common node includes
 * added here so node files don't have to include themselves
 */
#include "COM_CompositorContext.h"
#include "COM_NodeConverter.h"
 
namespace blender::compositor {
 
class NodeOperation;
class NodeConverter;
 
class Node {
 private:
  bNodeTree *editor_node_tree_;
 
  const bNode *editor_node_;
 
  bool in_active_group_;
 
  bNodeInstanceKey instance_key_;
 
 protected:
  Vector<NodeInput *> inputs_;
 
  Vector<NodeOutput *> outputs_;
 
 public:
  Node(bNode *editor_node, bool create_sockets = true);
  virtual ~Node();
 
  const bNode *get_bnode() const
  {
    return editor_node_;
  }
 
  bNodeTree *get_bnodetree() const
  {
    return editor_node_tree_;
  }
 
  void set_bnode(bNode *node)
  {
    editor_node_ = node;
  }
 
  void set_bnodetree(bNodeTree *nodetree)
  {
    editor_node_tree_ = nodetree;
  }
 
  Span<NodeInput *> get_input_sockets() const
  {
    return inputs_;
  }
 
  Span<NodeOutput *> get_output_sockets() const
  {
    return outputs_;
  }
 
  NodeOutput *get_output_socket(unsigned int index = 0) const;
 
  NodeInput *get_input_socket(unsigned int index) const;
 
  void set_is_in_active_group(bool value)
  {
    in_active_group_ = value;
  }
 
  inline bool is_in_active_group() const
  {
    return in_active_group_;
  }
 
  virtual void convert_to_operations(NodeConverter &converter,
                                     const CompositorContext &context) const = 0;
 
  void set_instance_key(bNodeInstanceKey instance_key)
  {
    instance_key_ = instance_key;
  }
  bNodeInstanceKey get_instance_key() const
  {
    return instance_key_;
  }
 
 protected:
  void add_input_socket(DataType datatype);
  void add_input_socket(DataType datatype, bNodeSocket *socket);
 
  void add_output_socket(DataType datatype);
  void add_output_socket(DataType datatype, bNodeSocket *socket);
 
  bNodeSocket *get_editor_input_socket(int editor_node_input_socket_index);
  bNodeSocket *get_editor_output_socket(int editor_node_output_socket_index);
};
 
class NodeInput {
 private:
  Node *node_;
  bNodeSocket *editor_socket_;
 
  DataType datatype_;
 
  NodeOutput *link_;
 
 public:
  NodeInput(Node *node, bNodeSocket *b_socket, DataType datatype);
 
  Node *get_node() const
  {
    return node_;
  }
  DataType get_data_type() const
  {
    return datatype_;
  }
  bNodeSocket *get_bnode_socket() const
  {
    return editor_socket_;
  }
 
  void set_link(NodeOutput *link);
  bool is_linked() const
  {
    return link_;
  }
  NodeOutput *get_link()
  {
    return link_;
  }
 
  float get_editor_value_float() const;
  void get_editor_value_color(float *value) const;
  void get_editor_value_vector(float *value) const;
};
 
class NodeOutput {
 private:
  Node *node_;
  bNodeSocket *editor_socket_;
 
  DataType datatype_;
 
 public:
  NodeOutput(Node *node, bNodeSocket *b_socket, DataType datatype);
 
  Node *get_node() const
  {
    return node_;
  }
  DataType get_data_type() const
  {
    return datatype_;
  }
  bNodeSocket *get_bnode_socket() const
  {
    return editor_socket_;
  }
 
  float get_editor_value_float();
  void get_editor_value_color(float *value);
  void get_editor_value_vector(float *value);
};
 
}  // namespace blender::compositor