COM_Node.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * Copyright 2011, Blender Foundation.
 */
 
#pragma once
 
#include "BLI_vector.hh"
 
#include "DNA_node_types.h"
 
#include <algorithm>
#include <string>
 
/* 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 *m_editorNodeTree;
 
  bNode *m_editorNode;
 
  bool m_inActiveGroup;
 
  bNodeInstanceKey m_instanceKey;
 
 protected:
  Vector<NodeInput *> inputs;
 
  Vector<NodeOutput *> outputs;
 
 public:
  Node(bNode *editorNode, bool create_sockets = true);
  virtual ~Node();
 
  bNode *getbNode() const
  {
    return m_editorNode;
  }
 
  bNodeTree *getbNodeTree() const
  {
    return m_editorNodeTree;
  }
 
  void setbNode(bNode *node)
  {
    this->m_editorNode = node;
  }
 
  void setbNodeTree(bNodeTree *nodetree)
  {
    this->m_editorNodeTree = nodetree;
  }
 
  const Vector<NodeInput *> &getInputSockets() const
  {
    return this->inputs;
  }
 
  const Vector<NodeOutput *> &getOutputSockets() const
  {
    return this->outputs;
  }
 
  NodeOutput *getOutputSocket(const unsigned int index = 0) const;
 
  NodeInput *getInputSocket(const unsigned int index) const;
 
  void setIsInActiveGroup(bool value)
  {
    this->m_inActiveGroup = value;
  }
 
  inline bool isInActiveGroup() const
  {
    return this->m_inActiveGroup;
  }
 
  virtual void convertToOperations(NodeConverter &converter,
                                   const CompositorContext &context) const = 0;
 
  void setInstanceKey(bNodeInstanceKey instance_key)
  {
    m_instanceKey = instance_key;
  }
  bNodeInstanceKey getInstanceKey() const
  {
    return m_instanceKey;
  }
 
 protected:
  void addInputSocket(DataType datatype);
  void addInputSocket(DataType datatype, bNodeSocket *socket);
 
  void addOutputSocket(DataType datatype);
  void addOutputSocket(DataType datatype, bNodeSocket *socket);
 
  bNodeSocket *getEditorInputSocket(int editorNodeInputSocketIndex);
  bNodeSocket *getEditorOutputSocket(int editorNodeOutputSocketIndex);
};
 
class NodeInput {
 private:
  Node *m_node;
  bNodeSocket *m_editorSocket;
 
  DataType m_datatype;
 
  NodeOutput *m_link;
 
 public:
  NodeInput(Node *node, bNodeSocket *b_socket, DataType datatype);
 
  Node *getNode() const
  {
    return this->m_node;
  }
  DataType getDataType() const
  {
    return m_datatype;
  }
  bNodeSocket *getbNodeSocket() const
  {
    return this->m_editorSocket;
  }
 
  void setLink(NodeOutput *link);
  bool isLinked() const
  {
    return m_link;
  }
  NodeOutput *getLink()
  {
    return m_link;
  }
 
  float getEditorValueFloat() const;
  void getEditorValueColor(float *value) const;
  void getEditorValueVector(float *value) const;
};
 
class NodeOutput {
 private:
  Node *m_node;
  bNodeSocket *m_editorSocket;
 
  DataType m_datatype;
 
 public:
  NodeOutput(Node *node, bNodeSocket *b_socket, DataType datatype);
 
  Node *getNode() const
  {
    return this->m_node;
  }
  DataType getDataType() const
  {
    return m_datatype;
  }
  bNodeSocket *getbNodeSocket() const
  {
    return this->m_editorSocket;
  }
 
  float getEditorValueFloat();
  void getEditorValueColor(float *value);
  void getEditorValueVector(float *value);
};
 
}  // namespace blender::compositor