Cleanup: remove non-existing function declarations
[blender.git] / source / blender / compositor / intern / COM_Node.h
1 /*
2  * Copyright 2011, Blender Foundation.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor:
19  *      Jeroen Bakker
20  *      Monique Dewanchand
21  */
22
23 #ifndef __COM_NODE_H__
24 #define __COM_NODE_H__
25
26 #include "DNA_node_types.h"
27 #include <vector>
28 #include <string>
29 #include <algorithm>
30
31 /* common node includes
32  * added here so node files don't have to include themselves
33  */
34 #include "COM_CompositorContext.h"
35 #include "COM_NodeConverter.h"
36
37 class Node;
38 class NodeOperation;
39 class NodeConverter;
40
41 /**
42  * My node documentation.
43  */
44 class Node {
45 public:
46         typedef std::vector<NodeInput *> Inputs;
47         typedef std::vector<NodeOutput *> Outputs;
48
49 private:
50         /**
51          * \brief stores the reference to the SDNA bNode struct
52          */
53         bNodeTree *m_editorNodeTree;
54
55         /**
56          * \brief stores the reference to the SDNA bNode struct
57          */
58         bNode *m_editorNode;
59
60         /**
61          * \brief the list of actual inputsockets \see NodeInput
62          */
63         Inputs m_inputsockets;
64
65         /**
66          * \brief the list of actual outputsockets \see NodeOutput
67          */
68         Outputs m_outputsockets;
69
70         /**
71          * \brief Is this node part of the active group
72          */
73         bool m_inActiveGroup;
74
75         /**
76          * \brief Instance key to identify the node in an instance hash table
77          */
78         bNodeInstanceKey m_instanceKey;
79
80 protected:
81         /**
82          * \brief get access to the vector of input sockets
83          */
84         const Inputs &getInputSockets() const { return this->m_inputsockets; }
85
86         /**
87          * \brief get access to the vector of input sockets
88          */
89         const Outputs &getOutputSockets() const { return this->m_outputsockets; }
90
91 public:
92         Node(bNode *editorNode, bool create_sockets = true);
93         virtual ~Node();
94
95         /**
96          * \brief get the reference to the SDNA bNode struct
97          */
98         bNode *getbNode() const {return m_editorNode;}
99
100         /**
101          * \brief get the reference to the SDNA bNodeTree struct
102          */
103         bNodeTree *getbNodeTree() const {return m_editorNodeTree;}
104
105         /**
106          * \brief set the reference to the bNode
107          * \note used in Node instances to receive the storage/settings and complex node for highlight during execution
108          * \param bNode:
109          */
110         void setbNode(bNode *node) {this->m_editorNode = node;}
111
112         /**
113          * \brief set the reference to the bNodeTree
114          * \param bNodeTree:
115          */
116         void setbNodeTree(bNodeTree *nodetree) {this->m_editorNodeTree = nodetree;}
117
118         /**
119          * \brief Return the number of input sockets of this node.
120          */
121         unsigned int getNumberOfInputSockets() const { return this->m_inputsockets.size(); }
122
123         /**
124          * \brief Return the number of output sockets of this node.
125          */
126         unsigned int getNumberOfOutputSockets() const { return this->m_outputsockets.size(); }
127
128         /**
129          * get the reference to a certain outputsocket
130          * \param index:
131          * the index of the needed outputsocket
132          */
133         NodeOutput *getOutputSocket(const unsigned int index) const;
134
135         /**
136          * get the reference to the first outputsocket
137          * \param index:
138          * the index of the needed outputsocket
139          */
140         inline NodeOutput *getOutputSocket() const { return getOutputSocket(0); }
141
142         /**
143          * get the reference to a certain inputsocket
144          * \param index:
145          * the index of the needed inputsocket
146          */
147         NodeInput *getInputSocket(const unsigned int index) const;
148
149         /** Check if this is an input node
150          * An input node is a node that only has output sockets and no input sockets
151          */
152         bool isInputNode() const { return m_inputsockets.empty(); }
153
154         /**
155          * \brief Is this node in the active group (the group that is being edited)
156          * \param isInActiveGroup:
157          */
158         void setIsInActiveGroup(bool value) { this->m_inActiveGroup = value; }
159
160         /**
161          * \brief Is this node part of the active group
162          * the active group is the group that is currently being edited. When no group is edited,
163          * the active group will be the main tree (all nodes that are not part of a group will be active)
164          * \return bool [false:true]
165          */
166         inline bool isInActiveGroup() const { return this->m_inActiveGroup; }
167
168         /**
169          * \brief convert node to operation
170          *
171          * \todo this must be described further
172          *
173          * \param system: the ExecutionSystem where the operations need to be added
174          * \param context: reference to the CompositorContext
175          */
176         virtual void convertToOperations(NodeConverter &converter, const CompositorContext &context) const = 0;
177
178         /**
179          * Create dummy warning operation, use when we can't get the source data.
180          */
181         NodeOperation *convertToOperations_invalid_index(NodeConverter *compiler, int index) const;
182         /**
183          * when a node has no valid data (missing image or a group nodes ID pointer is NULL)
184          * call this function from #convertToOperations, this way the node sockets are converted
185          * into valid outputs, without this the compositor system gets confused and crashes, see [#32490]
186          */
187         void convertToOperations_invalid(NodeConverter *compiler) const;
188
189         void setInstanceKey(bNodeInstanceKey instance_key) { m_instanceKey = instance_key; }
190         bNodeInstanceKey getInstanceKey() const { return m_instanceKey; }
191
192 protected:
193         /**
194          * \brief add an NodeInput to the collection of inputsockets
195          * \note may only be called in an constructor
196          * \param socket: the NodeInput to add
197          */
198         void addInputSocket(DataType datatype);
199         void addInputSocket(DataType datatype, bNodeSocket *socket);
200
201         /**
202          * \brief add an NodeOutput to the collection of outputsockets
203          * \note may only be called in an constructor
204          * \param socket: the NodeOutput to add
205          */
206         void addOutputSocket(DataType datatype);
207         void addOutputSocket(DataType datatype, bNodeSocket *socket);
208
209         bNodeSocket *getEditorInputSocket(int editorNodeInputSocketIndex);
210         bNodeSocket *getEditorOutputSocket(int editorNodeOutputSocketIndex);
211 };
212
213
214 /**
215  * \brief NodeInput are sockets that can receive data/input
216  * \ingroup Model
217  */
218 class NodeInput {
219 private:
220         Node *m_node;
221         bNodeSocket *m_editorSocket;
222
223         DataType m_datatype;
224
225         /**
226          * \brief link connected to this NodeInput.
227          * An input socket can only have a single link
228          */
229         NodeOutput *m_link;
230
231 public:
232         NodeInput(Node *node, bNodeSocket *b_socket, DataType datatype);
233
234         Node *getNode() const { return this->m_node; }
235         DataType getDataType() const { return m_datatype; }
236         bNodeSocket *getbNodeSocket() const { return this->m_editorSocket; }
237
238         void setLink(NodeOutput *link);
239         bool isLinked() const { return m_link; }
240         NodeOutput *getLink() { return m_link; }
241
242         float getEditorValueFloat();
243         void getEditorValueColor(float *value);
244         void getEditorValueVector(float *value);
245 };
246
247
248 /**
249  * \brief NodeOutput are sockets that can send data/input
250  * \ingroup Model
251  */
252 class NodeOutput {
253 private:
254         Node *m_node;
255         bNodeSocket *m_editorSocket;
256
257         DataType m_datatype;
258
259 public:
260         NodeOutput(Node *node, bNodeSocket *b_socket, DataType datatype);
261
262         Node *getNode() const { return this->m_node; }
263         DataType getDataType() const { return m_datatype; }
264         bNodeSocket *getbNodeSocket() const { return this->m_editorSocket; }
265
266         float getEditorValueFloat();
267         void getEditorValueColor(float *value);
268         void getEditorValueVector(float *value);
269 };
270
271 #endif  /* __COM_NODE_H__ */