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