Fix T63415: no Cycles displacement update when updating OSL code
[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 };
71
72 /* Input
73  *
74  * Input socket for a shader node. May be linked to an output or not. If not
75  * linked, it will either get a fixed default value, or e.g. a texture
76  * coordinate. */
77
78 class ShaderInput {
79  public:
80   ShaderInput(const SocketType &socket_type_, ShaderNode *parent_)
81       : socket_type(socket_type_), parent(parent_), link(NULL), stack_offset(SVM_STACK_INVALID)
82   {
83   }
84
85   ustring name()
86   {
87     return socket_type.ui_name;
88   }
89   int flags()
90   {
91     return socket_type.flags;
92   }
93   SocketType::Type type()
94   {
95     return socket_type.type;
96   }
97
98   void set(float f)
99   {
100     ((Node *)parent)->set(socket_type, f);
101   }
102   void set(float3 f)
103   {
104     ((Node *)parent)->set(socket_type, f);
105   }
106
107   const SocketType &socket_type;
108   ShaderNode *parent;
109   ShaderOutput *link;
110   int stack_offset; /* for SVM compiler */
111 };
112
113 /* Output
114  *
115  * Output socket for a shader node. */
116
117 class ShaderOutput {
118  public:
119   ShaderOutput(const SocketType &socket_type_, ShaderNode *parent_)
120       : socket_type(socket_type_), parent(parent_), stack_offset(SVM_STACK_INVALID)
121   {
122   }
123
124   ustring name()
125   {
126     return socket_type.ui_name;
127   }
128   SocketType::Type type()
129   {
130     return socket_type.type;
131   }
132
133   const SocketType &socket_type;
134   ShaderNode *parent;
135   vector<ShaderInput *> links;
136   int stack_offset; /* for SVM compiler */
137 };
138
139 /* Node
140  *
141  * Shader node in graph, with input and output sockets. This is the virtual
142  * base class for all node types. */
143
144 class ShaderNode : public Node {
145  public:
146   explicit ShaderNode(const NodeType *type);
147   virtual ~ShaderNode();
148
149   void create_inputs_outputs(const NodeType *type);
150
151   ShaderInput *input(const char *name);
152   ShaderOutput *output(const char *name);
153   ShaderInput *input(ustring name);
154   ShaderOutput *output(ustring name);
155
156   virtual ShaderNode *clone() const = 0;
157   virtual void attributes(Shader *shader, AttributeRequestSet *attributes);
158   virtual void compile(SVMCompiler &compiler) = 0;
159   virtual void compile(OSLCompiler &compiler) = 0;
160
161   /* ** Node optimization ** */
162   /* Check whether the node can be replaced with single constant. */
163   virtual void constant_fold(const ConstantFolder & /*folder*/)
164   {
165   }
166
167   /* Simplify settings used by artists to the ones which are simpler to
168    * evaluate in the kernel but keep the final result unchanged.
169    */
170   virtual void simplify_settings(Scene * /*scene*/){};
171
172   virtual bool has_surface_emission()
173   {
174     return false;
175   }
176   virtual bool has_surface_transparent()
177   {
178     return false;
179   }
180   virtual bool has_surface_bssrdf()
181   {
182     return false;
183   }
184   virtual bool has_bump()
185   {
186     return false;
187   }
188   virtual bool has_bssrdf_bump()
189   {
190     return false;
191   }
192   virtual bool has_spatial_varying()
193   {
194     return false;
195   }
196   virtual bool has_object_dependency()
197   {
198     return false;
199   }
200   virtual bool has_attribute_dependency()
201   {
202     return false;
203   }
204   virtual bool has_integrator_dependency()
205   {
206     return false;
207   }
208   virtual bool has_volume_support()
209   {
210     return false;
211   }
212   virtual bool has_raytrace()
213   {
214     return false;
215   }
216   vector<ShaderInput *> inputs;
217   vector<ShaderOutput *> outputs;
218
219   int id;          /* index in graph node array */
220   ShaderBump bump; /* for bump mapping utility */
221
222   ShaderNodeSpecialType special_type; /* special node type */
223
224   /* ** Selective nodes compilation ** */
225
226   /* TODO(sergey): More explicitly mention in the function names
227    * that those functions are for selective compilation only?
228    */
229
230   /* Nodes are split into several groups, group of level 0 contains
231    * nodes which are most commonly used, further levels are extension
232    * of previous one and includes less commonly used nodes.
233    */
234   virtual int get_group()
235   {
236     return NODE_GROUP_LEVEL_0;
237   }
238
239   /* Node feature are used to disable huge nodes inside the group,
240    * so it's possible to disable huge nodes inside of the required
241    * nodes group.
242    */
243   virtual int get_feature()
244   {
245     return bump == SHADER_BUMP_NONE ? 0 : NODE_FEATURE_BUMP;
246   }
247
248   /* Get closure ID to which the node compiles into. */
249   virtual ClosureType get_closure_type()
250   {
251     return CLOSURE_NONE_ID;
252   }
253
254   /* Check whether settings of the node equals to another one.
255    *
256    * This is mainly used to check whether two nodes can be merged
257    * together. Meaning, runtime stuff like node id and unbound slots
258    * will be ignored for comparison.
259    *
260    * NOTE: If some node can't be de-duplicated for whatever reason it
261    * is to be handled in the subclass.
262    */
263   virtual bool equals(const ShaderNode &other);
264 };
265
266 /* Node definition utility macros */
267
268 #define SHADER_NODE_CLASS(type) \
269   NODE_DECLARE \
270   type(); \
271   virtual ShaderNode *clone() const \
272   { \
273     return new type(*this); \
274   } \
275   virtual void compile(SVMCompiler &compiler); \
276   virtual void compile(OSLCompiler &compiler);
277
278 #define SHADER_NODE_NO_CLONE_CLASS(type) \
279   NODE_DECLARE \
280   type(); \
281   virtual void compile(SVMCompiler &compiler); \
282   virtual void compile(OSLCompiler &compiler);
283
284 #define SHADER_NODE_BASE_CLASS(type) \
285   virtual ShaderNode *clone() const \
286   { \
287     return new type(*this); \
288   } \
289   virtual void compile(SVMCompiler &compiler); \
290   virtual void compile(OSLCompiler &compiler);
291
292 class ShaderNodeIDComparator {
293  public:
294   bool operator()(const ShaderNode *n1, const ShaderNode *n2) const
295   {
296     return n1->id < n2->id;
297   }
298 };
299
300 typedef set<ShaderNode *, ShaderNodeIDComparator> ShaderNodeSet;
301 typedef map<ShaderNode *, ShaderNode *, ShaderNodeIDComparator> ShaderNodeMap;
302
303 /* Graph
304  *
305  * Shader graph of nodes. Also does graph manipulations for default inputs,
306  * bump mapping from displacement, and possibly other things in the future. */
307
308 class ShaderGraph {
309  public:
310   list<ShaderNode *> nodes;
311   size_t num_node_ids;
312   bool finalized;
313   bool simplified;
314   string displacement_hash;
315
316   ShaderGraph();
317   ~ShaderGraph();
318
319   ShaderNode *add(ShaderNode *node);
320   OutputNode *output();
321
322   void connect(ShaderOutput *from, ShaderInput *to);
323   void disconnect(ShaderOutput *from);
324   void disconnect(ShaderInput *to);
325   void relink(ShaderNode *node, ShaderOutput *from, ShaderOutput *to);
326
327   void remove_proxy_nodes();
328   void compute_displacement_hash();
329   void simplify(Scene *scene);
330   void finalize(Scene *scene,
331                 bool do_bump = false,
332                 bool do_simplify = false,
333                 bool bump_in_object_space = false);
334
335   int get_num_closures();
336
337   void dump_graph(const char *filename);
338
339  protected:
340   typedef pair<ShaderNode *const, ShaderNode *> NodePair;
341
342   void find_dependencies(ShaderNodeSet &dependencies, ShaderInput *input);
343   void clear_nodes();
344   void copy_nodes(ShaderNodeSet &nodes, ShaderNodeMap &nnodemap);
345
346   void break_cycles(ShaderNode *node, vector<bool> &visited, vector<bool> &on_stack);
347   void bump_from_displacement(bool use_object_space);
348   void refine_bump_nodes();
349   void default_inputs(bool do_osl);
350   void transform_multi_closure(ShaderNode *node, ShaderOutput *weight_out, bool volume);
351
352   /* Graph simplification routines. */
353   void clean(Scene *scene);
354   void constant_fold(Scene *scene);
355   void simplify_settings(Scene *scene);
356   void deduplicate_nodes();
357   void verify_volume_output();
358 };
359
360 CCL_NAMESPACE_END
361
362 #endif /* __GRAPH_H__ */