Cycles: Remove Bump Node from the graph, if Height input is not connected.
[blender.git] / intern / cycles / render / graph.h
1 /*
2  * Copyright 2011-2013 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 "kernel_types.h"
21
22 #include "util_list.h"
23 #include "util_map.h"
24 #include "util_param.h"
25 #include "util_set.h"
26 #include "util_types.h"
27 #include "util_vector.h"
28
29 CCL_NAMESPACE_BEGIN
30
31 class AttributeRequestSet;
32 class Shader;
33 class ShaderInput;
34 class ShaderOutput;
35 class ShaderNode;
36 class ShaderGraph;
37 class SVMCompiler;
38 class OSLCompiler;
39 class OutputNode;
40
41 /* Socket Type
42  *
43  * Data type for inputs and outputs */
44
45 enum ShaderSocketType {
46         SHADER_SOCKET_UNDEFINED,
47         
48         SHADER_SOCKET_FLOAT,
49         SHADER_SOCKET_INT,
50         SHADER_SOCKET_COLOR,
51         SHADER_SOCKET_VECTOR,
52         SHADER_SOCKET_POINT,
53         SHADER_SOCKET_NORMAL,
54         SHADER_SOCKET_CLOSURE,
55         SHADER_SOCKET_STRING
56 };
57
58 /* Bump
59  *
60  * For bump mapping, a node may be evaluated multiple times, using different
61  * samples to reconstruct the normal, this indicates the sample position */
62
63 enum ShaderBump {
64         SHADER_BUMP_NONE,
65         SHADER_BUMP_CENTER,
66         SHADER_BUMP_DX,
67         SHADER_BUMP_DY
68 };
69
70 /* Identifiers for some special node types.
71  *
72  * The graph needs to identify these in the clean function.
73  * Cannot use dynamic_cast, as this is disabled for OSL. */
74
75 enum ShaderNodeSpecialType {
76         SHADER_SPECIAL_TYPE_NONE,
77         SHADER_SPECIAL_TYPE_PROXY,
78         SHADER_SPECIAL_TYPE_MIX_CLOSURE,
79         SHADER_SPECIAL_TYPE_MIX_RGB, /* Only Mix subtype */
80         SHADER_SPECIAL_TYPE_AUTOCONVERT,
81         SHADER_SPECIAL_TYPE_GEOMETRY,
82         SHADER_SPECIAL_TYPE_SCRIPT,
83         SHADER_SPECIAL_TYPE_BACKGROUND,
84         SHADER_SPECIAL_TYPE_IMAGE_SLOT,
85         SHADER_SPECIAL_TYPE_CLOSURE,
86         SHADER_SPECIAL_TYPE_EMISSION,
87         SHADER_SPECIAL_TYPE_BUMP,
88 };
89
90 /* Enum
91  *
92  * Utility class for enum values. */
93
94 class ShaderEnum {
95 public:
96         bool empty() const { return left.empty(); }
97         void insert(const char *x, int y) {
98                 left[ustring(x)] = y;
99                 right[y] = ustring(x);
100         }
101
102         bool exists(ustring x) { return left.find(x) != left.end(); }
103         bool exists(int y) { return right.find(y) != right.end(); }
104
105         int operator[](const char *x) { return left[ustring(x)]; }
106         int operator[](ustring x) { return left[x]; }
107         ustring operator[](int y) { return right[y]; }
108
109 protected:
110         map<ustring, int> left;
111         map<int, ustring> right;
112 };
113
114 /* Input
115  *
116  * Input socket for a shader node. May be linked to an output or not. If not
117  * linked, it will either get a fixed default value, or e.g. a texture
118  * coordinate. */
119
120 class ShaderInput {
121 public:
122         enum DefaultValue {
123                 TEXTURE_GENERATED,
124                 TEXTURE_UV,
125                 INCOMING,
126                 NORMAL,
127                 POSITION,
128                 TANGENT,
129                 NONE
130         };
131
132         enum Usage {
133                 USE_SVM = 1,
134                 USE_OSL = 2,
135                 USE_ALL = USE_SVM|USE_OSL
136         };
137
138         ShaderInput(ShaderNode *parent, const char *name, ShaderSocketType type);
139         void set(const float3& v) { value = v; }
140         void set(float f) { value = make_float3(f, 0, 0); }
141         void set(const ustring v) { value_string = v; }
142
143         const char *name;
144         ShaderSocketType type;
145
146         ShaderNode *parent;
147         ShaderOutput *link;
148
149         DefaultValue default_value;
150         float3 value;
151         ustring value_string;
152
153         int stack_offset; /* for SVM compiler */
154         int usage;
155 };
156
157 /* Output
158  *
159  * Output socket for a shader node. */
160
161 class ShaderOutput {
162 public:
163         ShaderOutput(ShaderNode *parent, const char *name, ShaderSocketType type);
164
165         const char *name;
166         ShaderNode *parent;
167         ShaderSocketType type;
168
169         vector<ShaderInput*> links;
170
171         int stack_offset; /* for SVM compiler */
172 };
173
174 /* Node
175  *
176  * Shader node in graph, with input and output sockets. This is the virtual
177  * base class for all node types. */
178
179 class ShaderNode {
180 public:
181         ShaderNode(const char *name);
182         virtual ~ShaderNode();
183
184         ShaderInput *input(const char *name);
185         ShaderOutput *output(const char *name);
186
187         ShaderInput *add_input(const char *name, ShaderSocketType type, float value=0.0f, int usage=ShaderInput::USE_ALL);
188         ShaderInput *add_input(const char *name, ShaderSocketType type, float3 value, int usage=ShaderInput::USE_ALL);
189         ShaderInput *add_input(const char *name, ShaderSocketType type, ShaderInput::DefaultValue value, int usage=ShaderInput::USE_ALL);
190         ShaderOutput *add_output(const char *name, ShaderSocketType type);
191
192         virtual ShaderNode *clone() const = 0;
193         virtual void attributes(Shader *shader, AttributeRequestSet *attributes);
194         virtual void compile(SVMCompiler& compiler) = 0;
195         virtual void compile(OSLCompiler& compiler) = 0;
196
197         virtual bool has_surface_emission() { return false; }
198         virtual bool has_surface_transparent() { return false; }
199         virtual bool has_surface_bssrdf() { return false; }
200         virtual bool has_bssrdf_bump() { return false; }
201         virtual bool has_spatial_varying() { return false; }
202         virtual bool has_object_dependency() { return false; }
203
204         vector<ShaderInput*> inputs;
205         vector<ShaderOutput*> outputs;
206
207         ustring name; /* name, not required to be unique */
208         int id; /* index in graph node array */
209         ShaderBump bump; /* for bump mapping utility */
210         
211         ShaderNodeSpecialType special_type;     /* special node type */
212
213         /* ** Selective nodes compilation ** */
214
215         /* TODO(sergey): More explicitly mention in the function names
216          * that those functions are for selective compilation only?
217          */
218
219         /* Nodes are split into several groups, group of level 0 contains
220          * nodes which are most commonly used, further levels are extension
221          * of previous one and includes less commonly used nodes.
222          */
223         virtual int get_group() { return NODE_GROUP_LEVEL_0; }
224
225         /* Node feature are used to disable huge nodes inside the group,
226          * so it's possible to disable huge nodes inside of the required
227          * nodes group.
228          */
229         virtual int get_feature() { return bump == SHADER_BUMP_NONE ? 0 : NODE_FEATURE_BUMP; }
230 };
231
232
233 /* Node definition utility macros */
234
235 #define SHADER_NODE_CLASS(type) \
236         type(); \
237         virtual ShaderNode *clone() const { return new type(*this); } \
238         virtual void compile(SVMCompiler& compiler); \
239         virtual void compile(OSLCompiler& compiler); \
240
241 #define SHADER_NODE_NO_CLONE_CLASS(type) \
242         type(); \
243         virtual void compile(SVMCompiler& compiler); \
244         virtual void compile(OSLCompiler& compiler); \
245
246 #define SHADER_NODE_BASE_CLASS(type) \
247         virtual ShaderNode *clone() const { return new type(*this); } \
248         virtual void compile(SVMCompiler& compiler); \
249         virtual void compile(OSLCompiler& compiler); \
250
251 /* Graph
252  *
253  * Shader graph of nodes. Also does graph manipulations for default inputs,
254  * bump mapping from displacement, and possibly other things in the future. */
255
256 class ShaderGraph {
257 public:
258         list<ShaderNode*> nodes;
259         size_t num_node_ids;
260         bool finalized;
261
262         ShaderGraph();
263         ~ShaderGraph();
264
265         ShaderGraph *copy();
266
267         ShaderNode *add(ShaderNode *node);
268         OutputNode *output();
269
270         void connect(ShaderOutput *from, ShaderInput *to);
271         void disconnect(ShaderInput *to);
272         void relink(vector<ShaderInput*> inputs, vector<ShaderInput*> outputs, ShaderOutput *output);
273
274         void remove_unneeded_nodes();
275         void finalize(bool do_bump = false, bool do_osl = false);
276
277         int get_num_closures();
278
279         void dump_graph(const char *filename);
280
281 protected:
282         typedef pair<ShaderNode* const, ShaderNode*> NodePair;
283
284         void find_dependencies(set<ShaderNode*>& dependencies, ShaderInput *input);
285         void copy_nodes(set<ShaderNode*>& nodes, map<ShaderNode*, ShaderNode*>& nnodemap);
286
287         void break_cycles(ShaderNode *node, vector<bool>& visited, vector<bool>& on_stack);
288         void clean();
289         void bump_from_displacement();
290         void refine_bump_nodes();
291         void default_inputs(bool do_osl);
292         void transform_multi_closure(ShaderNode *node, ShaderOutput *weight_out, bool volume);
293 };
294
295 CCL_NAMESPACE_END
296
297 #endif /* __GRAPH_H__ */
298