GHOST: bundle tablet data with GHOST event
[blender.git] / intern / cycles / render / graph.h
1 /*
2  * Copyright 2011-2016 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #ifndef __GRAPH_H__
18 #define __GRAPH_H__
19
20 #include "graph/node.h"
21 #include "graph/node_type.h"
22
23 #include "kernel/kernel_types.h"
24
25 #include "util/util_list.h"
26 #include "util/util_map.h"
27 #include "util/util_param.h"
28 #include "util/util_set.h"
29 #include "util/util_types.h"
30 #include "util/util_vector.h"
31
32 CCL_NAMESPACE_BEGIN
33
34 class AttributeRequestSet;
35 class Scene;
36 class Shader;
37 class ShaderInput;
38 class ShaderOutput;
39 class ShaderNode;
40 class ShaderGraph;
41 class SVMCompiler;
42 class OSLCompiler;
43 class OutputNode;
44 class ConstantFolder;
45 class MD5Hash;
46
47 /* Bump
48  *
49  * For bump mapping, a node may be evaluated multiple times, using different
50  * samples to reconstruct the normal, this indicates the sample position */
51
52 enum ShaderBump { SHADER_BUMP_NONE, SHADER_BUMP_CENTER, SHADER_BUMP_DX, SHADER_BUMP_DY };
53
54 /* Identifiers for some special node types.
55  *
56  * The graph needs to identify these in the clean function.
57  * Cannot use dynamic_cast, as this is disabled for OSL. */
58
59 enum ShaderNodeSpecialType {
60   SHADER_SPECIAL_TYPE_NONE,
61   SHADER_SPECIAL_TYPE_PROXY,
62   SHADER_SPECIAL_TYPE_AUTOCONVERT,
63   SHADER_SPECIAL_TYPE_GEOMETRY,
64   SHADER_SPECIAL_TYPE_OSL,
65   SHADER_SPECIAL_TYPE_IMAGE_SLOT,
66   SHADER_SPECIAL_TYPE_CLOSURE,
67   SHADER_SPECIAL_TYPE_COMBINE_CLOSURE,
68   SHADER_SPECIAL_TYPE_OUTPUT,
69   SHADER_SPECIAL_TYPE_BUMP,
70   SHADER_SPECIAL_TYPE_OUTPUT_AOV,
71 };
72
73 /* Input
74  *
75  * Input socket for a shader node. May be linked to an output or not. If not
76  * linked, it will either get a fixed default value, or e.g. a texture
77  * coordinate. */
78
79 class ShaderInput {
80  public:
81   ShaderInput(const SocketType &socket_type_, ShaderNode *parent_)
82       : socket_type(socket_type_), parent(parent_), link(NULL), stack_offset(SVM_STACK_INVALID)
83   {
84   }
85
86   ustring name()
87   {
88     return socket_type.ui_name;
89   }
90   int flags()
91   {
92     return socket_type.flags;
93   }
94   SocketType::Type type()
95   {
96     return socket_type.type;
97   }
98
99   void set(float f)
100   {
101     ((Node *)parent)->set(socket_type, f);
102   }
103   void set(float3 f)
104   {
105     ((Node *)parent)->set(socket_type, f);
106   }
107
108   void disconnect();
109
110   const SocketType &socket_type;
111   ShaderNode *parent;
112   ShaderOutput *link;
113   int stack_offset; /* for SVM compiler */
114 };
115
116 /* Output
117  *
118  * Output socket for a shader node. */
119
120 class ShaderOutput {
121  public:
122   ShaderOutput(const SocketType &socket_type_, ShaderNode *parent_)
123       : socket_type(socket_type_), parent(parent_), stack_offset(SVM_STACK_INVALID)
124   {
125   }
126
127   ustring name()
128   {
129     return socket_type.ui_name;
130   }
131   SocketType::Type type()
132   {
133     return socket_type.type;
134   }
135
136   void disconnect();
137
138   const SocketType &socket_type;
139   ShaderNode *parent;
140   vector<ShaderInput *> links;
141   int stack_offset; /* for SVM compiler */
142 };
143
144 /* Node
145  *
146  * Shader node in graph, with input and output sockets. This is the virtual
147  * base class for all node types. */
148
149 class ShaderNode : public Node {
150  public:
151   explicit ShaderNode(const NodeType *type);
152   virtual ~ShaderNode();
153
154   void create_inputs_outputs(const NodeType *type);
155   void remove_input(ShaderInput *input);
156
157   ShaderInput *input(const char *name);
158   ShaderOutput *output(const char *name);
159   ShaderInput *input(ustring name);
160   ShaderOutput *output(ustring name);
161
162   virtual ShaderNode *clone() const = 0;
163   virtual void attributes(Shader *shader, AttributeRequestSet *attributes);
164   virtual void compile(SVMCompiler &compiler) = 0;
165   virtual void compile(OSLCompiler &compiler) = 0;
166
167   /* Expand node into additional nodes. */
168   virtual void expand(ShaderGraph * /* graph */)
169   {
170   }
171
172   /* ** Node optimization ** */
173   /* Check whether the node can be replaced with single constant. */
174   virtual void constant_fold(const ConstantFolder & /*folder*/)
175   {
176   }
177
178   /* Simplify settings used by artists to the ones which are simpler to
179    * evaluate in the kernel but keep the final result unchanged.
180    */
181   virtual void simplify_settings(Scene * /*scene*/){};
182
183   virtual bool has_surface_emission()
184   {
185     return false;
186   }
187   virtual bool has_surface_transparent()
188   {
189     return false;
190   }
191   virtual bool has_surface_bssrdf()
192   {
193     return false;
194   }
195   virtual bool has_bump()
196   {
197     return false;
198   }
199   virtual bool has_bssrdf_bump()
200   {
201     return false;
202   }
203   virtual bool has_spatial_varying()
204   {
205     return false;
206   }
207   virtual bool has_object_dependency()
208   {
209     return false;
210   }
211   virtual bool has_attribute_dependency()
212   {
213     return false;
214   }
215   virtual bool has_integrator_dependency()
216   {
217     return false;
218   }
219   virtual bool has_volume_support()
220   {
221     return false;
222   }
223   virtual bool has_raytrace()
224   {
225     return false;
226   }
227   vector<ShaderInput *> inputs;
228   vector<ShaderOutput *> outputs;
229
230   int id;          /* index in graph node array */
231   ShaderBump bump; /* for bump mapping utility */
232
233   ShaderNodeSpecialType special_type; /* special node type */
234
235   /* ** Selective nodes compilation ** */
236
237   /* TODO(sergey): More explicitly mention in the function names
238    * that those functions are for selective compilation only?
239    */
240
241   /* Nodes are split into several groups, group of level 0 contains
242    * nodes which are most commonly used, further levels are extension
243    * of previous one and includes less commonly used nodes.
244    */
245   virtual int get_group()
246   {
247     return NODE_GROUP_LEVEL_0;
248   }
249
250   /* Node feature are used to disable huge nodes inside the group,
251    * so it's possible to disable huge nodes inside of the required
252    * nodes group.
253    */
254   virtual int get_feature()
255   {
256     return bump == SHADER_BUMP_NONE ? 0 : NODE_FEATURE_BUMP;
257   }
258
259   /* Get closure ID to which the node compiles into. */
260   virtual ClosureType get_closure_type()
261   {
262     return CLOSURE_NONE_ID;
263   }
264
265   /* Check whether settings of the node equals to another one.
266    *
267    * This is mainly used to check whether two nodes can be merged
268    * together. Meaning, runtime stuff like node id and unbound slots
269    * will be ignored for comparison.
270    *
271    * NOTE: If some node can't be de-duplicated for whatever reason it
272    * is to be handled in the subclass.
273    */
274   virtual bool equals(const ShaderNode &other);
275 };
276
277 /* Node definition utility macros */
278
279 #define SHADER_NODE_CLASS(type) \
280   NODE_DECLARE \
281   type(); \
282   virtual ShaderNode *clone() const \
283   { \
284     return new type(*this); \
285   } \
286   virtual void compile(SVMCompiler &compiler); \
287   virtual void compile(OSLCompiler &compiler);
288
289 #define SHADER_NODE_NO_CLONE_CLASS(type) \
290   NODE_DECLARE \
291   type(); \
292   virtual void compile(SVMCompiler &compiler); \
293   virtual void compile(OSLCompiler &compiler);
294
295 #define SHADER_NODE_BASE_CLASS(type) \
296   virtual ShaderNode *clone() const \
297   { \
298     return new type(*this); \
299   } \
300   virtual void compile(SVMCompiler &compiler); \
301   virtual void compile(OSLCompiler &compiler);
302
303 class ShaderNodeIDComparator {
304  public:
305   bool operator()(const ShaderNode *n1, const ShaderNode *n2) const
306   {
307     return n1->id < n2->id;
308   }
309 };
310
311 typedef set<ShaderNode *, ShaderNodeIDComparator> ShaderNodeSet;
312 typedef map<ShaderNode *, ShaderNode *, ShaderNodeIDComparator> ShaderNodeMap;
313
314 /* Graph
315  *
316  * Shader graph of nodes. Also does graph manipulations for default inputs,
317  * bump mapping from displacement, and possibly other things in the future. */
318
319 class ShaderGraph {
320  public:
321   list<ShaderNode *> nodes;
322   size_t num_node_ids;
323   bool finalized;
324   bool simplified;
325   string displacement_hash;
326
327   ShaderGraph();
328   ~ShaderGraph();
329
330   ShaderNode *add(ShaderNode *node);
331   OutputNode *output();
332
333   void connect(ShaderOutput *from, ShaderInput *to);
334   void disconnect(ShaderOutput *from);
335   void disconnect(ShaderInput *to);
336   void relink(ShaderInput *from, ShaderInput *to);
337   void relink(ShaderOutput *from, ShaderOutput *to);
338   void relink(ShaderNode *node, ShaderOutput *from, ShaderOutput *to);
339
340   void remove_proxy_nodes();
341   void compute_displacement_hash();
342   void simplify(Scene *scene);
343   void finalize(Scene *scene,
344                 bool do_bump = false,
345                 bool do_simplify = false,
346                 bool bump_in_object_space = false);
347
348   int get_num_closures();
349
350   void dump_graph(const char *filename);
351
352  protected:
353   typedef pair<ShaderNode *const, ShaderNode *> NodePair;
354
355   void find_dependencies(ShaderNodeSet &dependencies, ShaderInput *input);
356   void clear_nodes();
357   void copy_nodes(ShaderNodeSet &nodes, ShaderNodeMap &nnodemap);
358
359   void break_cycles(ShaderNode *node, vector<bool> &visited, vector<bool> &on_stack);
360   void bump_from_displacement(bool use_object_space);
361   void refine_bump_nodes();
362   void expand();
363   void default_inputs(bool do_osl);
364   void transform_multi_closure(ShaderNode *node, ShaderOutput *weight_out, bool volume);
365
366   /* Graph simplification routines. */
367   void clean(Scene *scene);
368   void constant_fold(Scene *scene);
369   void simplify_settings(Scene *scene);
370   void deduplicate_nodes();
371   void verify_volume_output();
372 };
373
374 CCL_NAMESPACE_END
375
376 #endif /* __GRAPH_H__ */