Invert Color Cycles Node
[blender.git] / intern / cycles / render / nodes.h
1 /*
2  * Copyright 2011, Blender Foundation.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  */
18
19 #ifndef __NODES_H__
20 #define __NODES_H__
21
22 #include "graph.h"
23
24 #include "util_string.h"
25
26 CCL_NAMESPACE_BEGIN
27
28 class ImageManager;
29 class Shadr;
30
31 /* Texture Mapping */
32
33 class TextureMapping {
34 public:
35         TextureMapping();
36         Transform compute_transform();
37         bool skip();
38         void compile(SVMCompiler& compiler, int offset_in, int offset_out);
39
40         float3 translation;
41         float3 rotation;
42         float3 scale;
43
44         enum Mapping { NONE=0, X=1, Y=2, Z=3 };
45         Mapping x_mapping, y_mapping, z_mapping;
46
47         enum Projection { FLAT, CUBE, TUBE, SPHERE };
48         Projection projection;
49 };
50
51 /* Nodes */
52
53 class TextureNode : public ShaderNode {
54 public:
55         TextureNode(const char *name) : ShaderNode(name) {}
56         TextureMapping tex_mapping;
57 };
58
59 class ImageTextureNode : public TextureNode {
60 public:
61         SHADER_NODE_NO_CLONE_CLASS(ImageTextureNode)
62         ~ImageTextureNode();
63         ShaderNode *clone() const;
64
65         ImageManager *image_manager;
66         int slot;
67         string filename;
68         ustring color_space;
69
70         static ShaderEnum color_space_enum;
71 };
72
73 class EnvironmentTextureNode : public TextureNode {
74 public:
75         SHADER_NODE_NO_CLONE_CLASS(EnvironmentTextureNode)
76         ~EnvironmentTextureNode();
77         ShaderNode *clone() const;
78
79         ImageManager *image_manager;
80         int slot;
81         string filename;
82         ustring color_space;
83
84         static ShaderEnum color_space_enum;
85 };
86
87 class SkyTextureNode : public TextureNode {
88 public:
89         SHADER_NODE_CLASS(SkyTextureNode)
90
91         float3 sun_direction;
92         float turbidity;
93 };
94
95 class OutputNode : public ShaderNode {
96 public:
97         SHADER_NODE_CLASS(OutputNode)
98 };
99
100 class GradientTextureNode : public TextureNode {
101 public:
102         SHADER_NODE_CLASS(GradientTextureNode)
103
104         ustring type;
105         static ShaderEnum type_enum;
106 };
107
108 class NoiseTextureNode : public TextureNode {
109 public:
110         SHADER_NODE_CLASS(NoiseTextureNode)
111 };
112
113 class VoronoiTextureNode : public TextureNode {
114 public:
115         SHADER_NODE_CLASS(VoronoiTextureNode)
116
117         ustring coloring;
118
119         static ShaderEnum coloring_enum;
120 };
121
122 class MusgraveTextureNode : public TextureNode {
123 public:
124         SHADER_NODE_CLASS(MusgraveTextureNode)
125
126         ustring type;
127
128         static ShaderEnum type_enum;
129 };
130
131 class WaveTextureNode : public TextureNode {
132 public:
133         SHADER_NODE_CLASS(WaveTextureNode)
134
135         ustring type;
136         static ShaderEnum type_enum;
137 };
138
139 class MagicTextureNode : public TextureNode {
140 public:
141         SHADER_NODE_CLASS(MagicTextureNode)
142
143         int depth;
144 };
145
146 class MappingNode : public ShaderNode {
147 public:
148         SHADER_NODE_CLASS(MappingNode)
149
150         TextureMapping tex_mapping;
151 };
152
153 class ConvertNode : public ShaderNode {
154 public:
155         ConvertNode(ShaderSocketType from, ShaderSocketType to);
156         SHADER_NODE_BASE_CLASS(ConvertNode)
157
158         ShaderSocketType from, to;
159 };
160
161 class BsdfNode : public ShaderNode {
162 public:
163         SHADER_NODE_CLASS(BsdfNode)
164
165         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
166
167         ClosureType closure;
168 };
169
170 class WardBsdfNode : public BsdfNode {
171 public:
172         SHADER_NODE_CLASS(WardBsdfNode)
173 };
174
175 class DiffuseBsdfNode : public BsdfNode {
176 public:
177         SHADER_NODE_CLASS(DiffuseBsdfNode)
178 };
179
180 class TranslucentBsdfNode : public BsdfNode {
181 public:
182         SHADER_NODE_CLASS(TranslucentBsdfNode)
183 };
184
185 class TransparentBsdfNode : public BsdfNode {
186 public:
187         SHADER_NODE_CLASS(TransparentBsdfNode)
188 };
189
190 class VelvetBsdfNode : public BsdfNode {
191 public:
192         SHADER_NODE_CLASS(VelvetBsdfNode)
193 };
194
195 class GlossyBsdfNode : public BsdfNode {
196 public:
197         SHADER_NODE_CLASS(GlossyBsdfNode)
198
199         ustring distribution;
200         static ShaderEnum distribution_enum;
201 };
202
203 class GlassBsdfNode : public BsdfNode {
204 public:
205         SHADER_NODE_CLASS(GlassBsdfNode)
206
207         ustring distribution;
208         static ShaderEnum distribution_enum;
209 };
210
211 class EmissionNode : public ShaderNode {
212 public:
213         SHADER_NODE_CLASS(EmissionNode)
214
215         bool total_power;
216 };
217
218 class BackgroundNode : public ShaderNode {
219 public:
220         SHADER_NODE_CLASS(BackgroundNode)
221 };
222
223 class HoldoutNode : public ShaderNode {
224 public:
225         SHADER_NODE_CLASS(HoldoutNode)
226 };
227
228 class VolumeNode : public ShaderNode {
229 public:
230         SHADER_NODE_CLASS(VolumeNode)
231
232         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
233
234         ClosureType closure;
235 };
236
237 class TransparentVolumeNode : public VolumeNode {
238 public:
239         SHADER_NODE_CLASS(TransparentVolumeNode)
240 };
241
242 class IsotropicVolumeNode : public VolumeNode {
243 public:
244         SHADER_NODE_CLASS(IsotropicVolumeNode)
245 };
246
247 class GeometryNode : public ShaderNode {
248 public:
249         SHADER_NODE_CLASS(GeometryNode)
250 };
251
252 class TextureCoordinateNode : public ShaderNode {
253 public:
254         SHADER_NODE_CLASS(TextureCoordinateNode)
255         void attributes(AttributeRequestSet *attributes);
256 };
257
258 class LightPathNode : public ShaderNode {
259 public:
260         SHADER_NODE_CLASS(LightPathNode)
261 };
262
263 class ValueNode : public ShaderNode {
264 public:
265         SHADER_NODE_CLASS(ValueNode)
266
267         float value;
268 };
269
270 class ColorNode : public ShaderNode {
271 public:
272         SHADER_NODE_CLASS(ColorNode)
273
274         float3 value;
275 };
276
277 class AddClosureNode : public ShaderNode {
278 public:
279         SHADER_NODE_CLASS(AddClosureNode)
280 };
281
282 class MixClosureNode : public ShaderNode {
283 public:
284         SHADER_NODE_CLASS(MixClosureNode)
285 };
286
287 class InvertNode : public ShaderNode {
288 public:
289         SHADER_NODE_CLASS(InvertNode)
290 };
291
292 class MixNode : public ShaderNode {
293 public:
294         SHADER_NODE_CLASS(MixNode)
295
296         ustring type;
297         static ShaderEnum type_enum;
298 };
299
300 class CombineRGBNode : public ShaderNode {
301 public:
302         SHADER_NODE_CLASS(CombineRGBNode)
303 };
304
305 class SeparateRGBNode : public ShaderNode {
306 public:
307         SHADER_NODE_CLASS(SeparateRGBNode)
308 };
309
310 class HSVNode : public ShaderNode {
311 public:
312         SHADER_NODE_CLASS(HSVNode)
313 };
314
315 class AttributeNode : public ShaderNode {
316 public:
317         SHADER_NODE_CLASS(AttributeNode)
318         void attributes(AttributeRequestSet *attributes);
319
320         ustring attribute;
321 };
322
323 class CameraNode : public ShaderNode {
324 public:
325         SHADER_NODE_CLASS(CameraNode)
326 };
327
328 class FresnelNode : public ShaderNode {
329 public:
330         SHADER_NODE_CLASS(FresnelNode)
331 };
332
333 class LayerWeightNode : public ShaderNode {
334 public:
335         SHADER_NODE_CLASS(LayerWeightNode)
336 };
337
338 class MathNode : public ShaderNode {
339 public:
340         SHADER_NODE_CLASS(MathNode)
341
342         ustring type;
343         static ShaderEnum type_enum;
344 };
345
346 class VectorMathNode : public ShaderNode {
347 public:
348         SHADER_NODE_CLASS(VectorMathNode)
349
350         ustring type;
351         static ShaderEnum type_enum;
352 };
353
354 class BumpNode : public ShaderNode {
355 public:
356         SHADER_NODE_CLASS(BumpNode)
357 };
358
359 CCL_NAMESPACE_END
360
361 #endif /* __NODES_H__ */
362