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