Cycles: merge of changes from tomato branch.
[blender-staging.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         float3 min, max;
45         bool use_minmax;
46
47         enum Mapping { NONE = 0, X = 1, Y = 2, Z = 3 };
48         Mapping x_mapping, y_mapping, z_mapping;
49
50         enum Projection { FLAT, CUBE, TUBE, SPHERE };
51         Projection projection;
52 };
53
54 /* Nodes */
55
56 class TextureNode : public ShaderNode {
57 public:
58         TextureNode(const char *name_) : ShaderNode(name_) {}
59         TextureMapping tex_mapping;
60 };
61
62 class ImageTextureNode : public TextureNode {
63 public:
64         SHADER_NODE_NO_CLONE_CLASS(ImageTextureNode)
65         ~ImageTextureNode();
66         ShaderNode *clone() const;
67
68         ImageManager *image_manager;
69         int slot;
70         bool is_float;
71         string filename;
72         ustring color_space;
73         ustring projection;
74         float projection_blend;
75
76         static ShaderEnum color_space_enum;
77         static ShaderEnum projection_enum;
78 };
79
80 class EnvironmentTextureNode : public TextureNode {
81 public:
82         SHADER_NODE_NO_CLONE_CLASS(EnvironmentTextureNode)
83         ~EnvironmentTextureNode();
84         ShaderNode *clone() const;
85
86         ImageManager *image_manager;
87         int slot;
88         bool is_float;
89         string filename;
90         ustring color_space;
91         ustring projection;
92
93         static ShaderEnum color_space_enum;
94         static ShaderEnum projection_enum;
95 };
96
97 class SkyTextureNode : public TextureNode {
98 public:
99         SHADER_NODE_CLASS(SkyTextureNode)
100
101         float3 sun_direction;
102         float turbidity;
103 };
104
105 class OutputNode : public ShaderNode {
106 public:
107         SHADER_NODE_CLASS(OutputNode)
108 };
109
110 class GradientTextureNode : public TextureNode {
111 public:
112         SHADER_NODE_CLASS(GradientTextureNode)
113
114         ustring type;
115         static ShaderEnum type_enum;
116 };
117
118 class NoiseTextureNode : public TextureNode {
119 public:
120         SHADER_NODE_CLASS(NoiseTextureNode)
121 };
122
123 class VoronoiTextureNode : public TextureNode {
124 public:
125         SHADER_NODE_CLASS(VoronoiTextureNode)
126
127         ustring coloring;
128
129         static ShaderEnum coloring_enum;
130 };
131
132 class MusgraveTextureNode : public TextureNode {
133 public:
134         SHADER_NODE_CLASS(MusgraveTextureNode)
135
136         ustring type;
137
138         static ShaderEnum type_enum;
139 };
140
141 class WaveTextureNode : public TextureNode {
142 public:
143         SHADER_NODE_CLASS(WaveTextureNode)
144
145         ustring type;
146         static ShaderEnum type_enum;
147 };
148
149 class MagicTextureNode : public TextureNode {
150 public:
151         SHADER_NODE_CLASS(MagicTextureNode)
152
153         int depth;
154 };
155
156 class CheckerTextureNode : public TextureNode {
157 public:
158         SHADER_NODE_CLASS(CheckerTextureNode)
159 };
160
161 class BrickTextureNode : public TextureNode {
162 public:
163         SHADER_NODE_CLASS(BrickTextureNode)
164         
165         float offset, squash;
166         int offset_frequency, squash_frequency;
167 };
168
169 class MappingNode : public ShaderNode {
170 public:
171         SHADER_NODE_CLASS(MappingNode)
172
173         TextureMapping tex_mapping;
174 };
175
176 class ConvertNode : public ShaderNode {
177 public:
178         ConvertNode(ShaderSocketType from, ShaderSocketType to);
179         SHADER_NODE_BASE_CLASS(ConvertNode)
180
181         ShaderSocketType from, to;
182 };
183
184 class ProxyNode : public ShaderNode {
185 public:
186         ProxyNode(ShaderSocketType from, ShaderSocketType to);
187         SHADER_NODE_BASE_CLASS(ProxyNode)
188
189         ShaderSocketType from, to;
190 };
191
192 class BsdfNode : public ShaderNode {
193 public:
194         SHADER_NODE_CLASS(BsdfNode)
195
196         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
197
198         ClosureType closure;
199 };
200
201 class WardBsdfNode : public BsdfNode {
202 public:
203         SHADER_NODE_CLASS(WardBsdfNode)
204 };
205
206 class DiffuseBsdfNode : public BsdfNode {
207 public:
208         SHADER_NODE_CLASS(DiffuseBsdfNode)
209 };
210
211 class TranslucentBsdfNode : public BsdfNode {
212 public:
213         SHADER_NODE_CLASS(TranslucentBsdfNode)
214 };
215
216 class TransparentBsdfNode : public BsdfNode {
217 public:
218         SHADER_NODE_CLASS(TransparentBsdfNode)
219 };
220
221 class VelvetBsdfNode : public BsdfNode {
222 public:
223         SHADER_NODE_CLASS(VelvetBsdfNode)
224 };
225
226 class GlossyBsdfNode : public BsdfNode {
227 public:
228         SHADER_NODE_CLASS(GlossyBsdfNode)
229
230         ustring distribution;
231         static ShaderEnum distribution_enum;
232 };
233
234 class GlassBsdfNode : public BsdfNode {
235 public:
236         SHADER_NODE_CLASS(GlassBsdfNode)
237
238         ustring distribution;
239         static ShaderEnum distribution_enum;
240 };
241
242 class EmissionNode : public ShaderNode {
243 public:
244         SHADER_NODE_CLASS(EmissionNode)
245
246         bool total_power;
247 };
248
249 class BackgroundNode : public ShaderNode {
250 public:
251         SHADER_NODE_CLASS(BackgroundNode)
252 };
253
254 class HoldoutNode : public ShaderNode {
255 public:
256         SHADER_NODE_CLASS(HoldoutNode)
257 };
258
259 class VolumeNode : public ShaderNode {
260 public:
261         SHADER_NODE_CLASS(VolumeNode)
262
263         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
264
265         ClosureType closure;
266 };
267
268 class TransparentVolumeNode : public VolumeNode {
269 public:
270         SHADER_NODE_CLASS(TransparentVolumeNode)
271 };
272
273 class IsotropicVolumeNode : public VolumeNode {
274 public:
275         SHADER_NODE_CLASS(IsotropicVolumeNode)
276 };
277
278 class GeometryNode : public ShaderNode {
279 public:
280         SHADER_NODE_CLASS(GeometryNode)
281 };
282
283 class TextureCoordinateNode : public ShaderNode {
284 public:
285         SHADER_NODE_CLASS(TextureCoordinateNode)
286         void attributes(AttributeRequestSet *attributes);
287 };
288
289 class LightPathNode : public ShaderNode {
290 public:
291         SHADER_NODE_CLASS(LightPathNode)
292 };
293
294 class LightFalloffNode : public ShaderNode {
295 public:
296         SHADER_NODE_CLASS(LightFalloffNode)
297 };
298
299 class ObjectInfoNode : public ShaderNode {
300 public:
301         SHADER_NODE_CLASS(ObjectInfoNode)
302 };
303
304 class ParticleInfoNode : public ShaderNode {
305 public:
306         SHADER_NODE_CLASS(ParticleInfoNode)
307         void attributes(AttributeRequestSet *attributes);
308 };
309
310 class ValueNode : public ShaderNode {
311 public:
312         SHADER_NODE_CLASS(ValueNode)
313
314         float value;
315 };
316
317 class ColorNode : public ShaderNode {
318 public:
319         SHADER_NODE_CLASS(ColorNode)
320
321         float3 value;
322 };
323
324 class AddClosureNode : public ShaderNode {
325 public:
326         SHADER_NODE_CLASS(AddClosureNode)
327 };
328
329 class MixClosureNode : public ShaderNode {
330 public:
331         SHADER_NODE_CLASS(MixClosureNode)
332 };
333
334 class InvertNode : public ShaderNode {
335 public:
336         SHADER_NODE_CLASS(InvertNode)
337 };
338
339 class MixNode : public ShaderNode {
340 public:
341         SHADER_NODE_CLASS(MixNode)
342
343         bool use_clamp;
344
345         ustring type;
346         static ShaderEnum type_enum;
347 };
348
349 class CombineRGBNode : public ShaderNode {
350 public:
351         SHADER_NODE_CLASS(CombineRGBNode)
352 };
353
354 class GammaNode : public ShaderNode {
355 public:
356         SHADER_NODE_CLASS(GammaNode)
357 };
358
359 class BrightContrastNode : public ShaderNode {
360 public:
361         SHADER_NODE_CLASS(BrightContrastNode)
362 };
363
364 class SeparateRGBNode : public ShaderNode {
365 public:
366         SHADER_NODE_CLASS(SeparateRGBNode)
367 };
368
369 class HSVNode : public ShaderNode {
370 public:
371         SHADER_NODE_CLASS(HSVNode)
372 };
373
374 class AttributeNode : public ShaderNode {
375 public:
376         SHADER_NODE_CLASS(AttributeNode)
377         void attributes(AttributeRequestSet *attributes);
378
379         ustring attribute;
380 };
381
382 class CameraNode : public ShaderNode {
383 public:
384         SHADER_NODE_CLASS(CameraNode)
385 };
386
387 class FresnelNode : public ShaderNode {
388 public:
389         SHADER_NODE_CLASS(FresnelNode)
390 };
391
392 class LayerWeightNode : public ShaderNode {
393 public:
394         SHADER_NODE_CLASS(LayerWeightNode)
395 };
396
397 class MathNode : public ShaderNode {
398 public:
399         SHADER_NODE_CLASS(MathNode)
400
401         bool use_clamp;
402
403         ustring type;
404         static ShaderEnum type_enum;
405 };
406
407 class NormalNode : public ShaderNode {
408 public:
409         SHADER_NODE_CLASS(NormalNode)
410
411         float3 direction;
412 };
413
414 class VectorMathNode : public ShaderNode {
415 public:
416         SHADER_NODE_CLASS(VectorMathNode)
417
418         ustring type;
419         static ShaderEnum type_enum;
420 };
421
422 class BumpNode : public ShaderNode {
423 public:
424         SHADER_NODE_CLASS(BumpNode)
425 };
426
427 class RGBCurvesNode : public ShaderNode {
428 public:
429         SHADER_NODE_CLASS(RGBCurvesNode)
430         float4 curves[RAMP_TABLE_SIZE];
431 };
432
433 class RGBRampNode : public ShaderNode {
434 public:
435         SHADER_NODE_CLASS(RGBRampNode)
436         float4 ramp[RAMP_TABLE_SIZE];
437 };
438
439 CCL_NAMESPACE_END
440
441 #endif /* __NODES_H__ */
442