Cycles: Make all #include statements relative to cycles source directory
[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_bssrdf_bump() { return false; }
155         virtual bool has_spatial_varying() { return false; }
156         virtual bool has_object_dependency() { return false; }
157         virtual bool has_integrator_dependency() { return false; }
158
159         vector<ShaderInput*> inputs;
160         vector<ShaderOutput*> outputs;
161
162         int id; /* index in graph node array */
163         ShaderBump bump; /* for bump mapping utility */
164         
165         ShaderNodeSpecialType special_type;     /* special node type */
166
167         /* ** Selective nodes compilation ** */
168
169         /* TODO(sergey): More explicitly mention in the function names
170          * that those functions are for selective compilation only?
171          */
172
173         /* Nodes are split into several groups, group of level 0 contains
174          * nodes which are most commonly used, further levels are extension
175          * of previous one and includes less commonly used nodes.
176          */
177         virtual int get_group() { return NODE_GROUP_LEVEL_0; }
178
179         /* Node feature are used to disable huge nodes inside the group,
180          * so it's possible to disable huge nodes inside of the required
181          * nodes group.
182          */
183         virtual int get_feature() { return bump == SHADER_BUMP_NONE ? 0 : NODE_FEATURE_BUMP; }
184
185         /* Get closure ID to which the node compiles into. */
186         virtual ClosureType get_closure_type() { return CLOSURE_NONE_ID; }
187
188         /* Check whether settings of the node equals to another one.
189          *
190          * This is mainly used to check whether two nodes can be merged
191          * together. Meaning, runtime stuff like node id and unbound slots
192          * will be ignored for comparison.
193          *
194          * NOTE: If some node can't be de-duplicated for whatever reason it
195          * is to be handled in the subclass.
196          */
197         virtual bool equals(const ShaderNode& other);
198 };
199
200
201 /* Node definition utility macros */
202
203 #define SHADER_NODE_CLASS(type) \
204         NODE_DECLARE \
205         type(); \
206         virtual ShaderNode *clone() const { return new type(*this); } \
207         virtual void compile(SVMCompiler& compiler); \
208         virtual void compile(OSLCompiler& compiler); \
209
210 #define SHADER_NODE_NO_CLONE_CLASS(type) \
211         NODE_DECLARE \
212         type(); \
213         virtual void compile(SVMCompiler& compiler); \
214         virtual void compile(OSLCompiler& compiler); \
215
216 #define SHADER_NODE_BASE_CLASS(type) \
217         virtual ShaderNode *clone() const { return new type(*this); } \
218         virtual void compile(SVMCompiler& compiler); \
219         virtual void compile(OSLCompiler& compiler); \
220
221 class ShaderNodeIDComparator
222 {
223 public:
224         bool operator()(const ShaderNode *n1, const ShaderNode *n2) const
225         {
226                 return n1->id < n2->id;
227         }
228 };
229
230 typedef set<ShaderNode*, ShaderNodeIDComparator> ShaderNodeSet;
231 typedef map<ShaderNode*, ShaderNode*, ShaderNodeIDComparator> ShaderNodeMap;
232
233 /* Graph
234  *
235  * Shader graph of nodes. Also does graph manipulations for default inputs,
236  * bump mapping from displacement, and possibly other things in the future. */
237
238 class ShaderGraph {
239 public:
240         list<ShaderNode*> nodes;
241         size_t num_node_ids;
242         bool finalized;
243         bool simplified;
244
245         ShaderGraph();
246         ~ShaderGraph();
247
248         ShaderGraph *copy();
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 };
288
289 CCL_NAMESPACE_END
290
291 #endif /* __GRAPH_H__ */
292