Cycles:
[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 Shader;
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         void compile(OSLCompiler &compiler);
40
41         float3 translation;
42         float3 rotation;
43         float3 scale;
44
45         float3 min, max;
46         bool use_minmax;
47
48         enum Mapping { NONE = 0, X = 1, Y = 2, Z = 3 };
49         Mapping x_mapping, y_mapping, z_mapping;
50
51         enum Projection { FLAT, CUBE, TUBE, SPHERE };
52         Projection projection;
53 };
54
55 /* Nodes */
56
57 class TextureNode : public ShaderNode {
58 public:
59         TextureNode(const char *name_) : ShaderNode(name_) {}
60         TextureMapping tex_mapping;
61 };
62
63 class ImageTextureNode : public TextureNode {
64 public:
65         SHADER_NODE_NO_CLONE_CLASS(ImageTextureNode)
66         ~ImageTextureNode();
67         ShaderNode *clone() const;
68
69         ImageManager *image_manager;
70         int slot;
71         int is_float;
72         bool is_linear;
73         string filename;
74         void *builtin_data;
75         ustring color_space;
76         ustring projection;
77         float projection_blend;
78         bool animated;
79
80         static ShaderEnum color_space_enum;
81         static ShaderEnum projection_enum;
82 };
83
84 class EnvironmentTextureNode : public TextureNode {
85 public:
86         SHADER_NODE_NO_CLONE_CLASS(EnvironmentTextureNode)
87         ~EnvironmentTextureNode();
88         ShaderNode *clone() const;
89
90         ImageManager *image_manager;
91         int slot;
92         int is_float;
93         bool is_linear;
94         string filename;
95         void *builtin_data;
96         ustring color_space;
97         ustring projection;
98         bool animated;
99
100         static ShaderEnum color_space_enum;
101         static ShaderEnum projection_enum;
102 };
103
104 class SkyTextureNode : public TextureNode {
105 public:
106         SHADER_NODE_CLASS(SkyTextureNode)
107
108         float3 sun_direction;
109         float turbidity;
110 };
111
112 class OutputNode : public ShaderNode {
113 public:
114         SHADER_NODE_CLASS(OutputNode)
115 };
116
117 class GradientTextureNode : public TextureNode {
118 public:
119         SHADER_NODE_CLASS(GradientTextureNode)
120
121         ustring type;
122         static ShaderEnum type_enum;
123 };
124
125 class NoiseTextureNode : public TextureNode {
126 public:
127         SHADER_NODE_CLASS(NoiseTextureNode)
128 };
129
130 class VoronoiTextureNode : public TextureNode {
131 public:
132         SHADER_NODE_CLASS(VoronoiTextureNode)
133
134         ustring coloring;
135
136         static ShaderEnum coloring_enum;
137 };
138
139 class MusgraveTextureNode : public TextureNode {
140 public:
141         SHADER_NODE_CLASS(MusgraveTextureNode)
142
143         ustring type;
144
145         static ShaderEnum type_enum;
146 };
147
148 class WaveTextureNode : public TextureNode {
149 public:
150         SHADER_NODE_CLASS(WaveTextureNode)
151
152         ustring type;
153         static ShaderEnum type_enum;
154 };
155
156 class MagicTextureNode : public TextureNode {
157 public:
158         SHADER_NODE_CLASS(MagicTextureNode)
159
160         int depth;
161 };
162
163 class CheckerTextureNode : public TextureNode {
164 public:
165         SHADER_NODE_CLASS(CheckerTextureNode)
166 };
167
168 class BrickTextureNode : public TextureNode {
169 public:
170         SHADER_NODE_CLASS(BrickTextureNode)
171         
172         float offset, squash;
173         int offset_frequency, squash_frequency;
174 };
175
176 class MappingNode : public ShaderNode {
177 public:
178         SHADER_NODE_CLASS(MappingNode)
179
180         TextureMapping tex_mapping;
181 };
182
183 class ConvertNode : public ShaderNode {
184 public:
185         ConvertNode(ShaderSocketType from, ShaderSocketType to, bool autoconvert = false);
186         SHADER_NODE_BASE_CLASS(ConvertNode)
187
188         ShaderSocketType from, to;
189 };
190
191 class ProxyNode : public ShaderNode {
192 public:
193         ProxyNode(ShaderSocketType type);
194         SHADER_NODE_BASE_CLASS(ProxyNode)
195
196         ShaderSocketType type;
197 };
198
199 class BsdfNode : public ShaderNode {
200 public:
201         BsdfNode(bool scattering = false);
202         SHADER_NODE_BASE_CLASS(BsdfNode);
203
204         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2, ShaderInput *param3 = NULL);
205
206         ClosureType closure;
207         bool scattering;
208 };
209
210 class WardBsdfNode : public BsdfNode {
211 public:
212         SHADER_NODE_CLASS(WardBsdfNode)
213         void attributes(AttributeRequestSet *attributes);
214 };
215
216 class DiffuseBsdfNode : public BsdfNode {
217 public:
218         SHADER_NODE_CLASS(DiffuseBsdfNode)
219 };
220
221 class TranslucentBsdfNode : public BsdfNode {
222 public:
223         SHADER_NODE_CLASS(TranslucentBsdfNode)
224 };
225
226 class TransparentBsdfNode : public BsdfNode {
227 public:
228         SHADER_NODE_CLASS(TransparentBsdfNode)
229
230         bool has_surface_transparent() { return true; }
231 };
232
233 class VelvetBsdfNode : public BsdfNode {
234 public:
235         SHADER_NODE_CLASS(VelvetBsdfNode)
236 };
237
238 class GlossyBsdfNode : public BsdfNode {
239 public:
240         SHADER_NODE_CLASS(GlossyBsdfNode)
241
242         ustring distribution;
243         static ShaderEnum distribution_enum;
244 };
245
246 class GlassBsdfNode : public BsdfNode {
247 public:
248         SHADER_NODE_CLASS(GlassBsdfNode)
249
250         ustring distribution;
251         static ShaderEnum distribution_enum;
252 };
253
254 class RefractionBsdfNode : public BsdfNode {
255 public:
256         SHADER_NODE_CLASS(RefractionBsdfNode)
257
258         ustring distribution;
259         static ShaderEnum distribution_enum;
260 };
261
262 class ToonBsdfNode : public BsdfNode {
263 public:
264         SHADER_NODE_CLASS(ToonBsdfNode)
265
266         ustring component;
267         static ShaderEnum component_enum;
268 };
269
270 class SubsurfaceScatteringNode : public BsdfNode {
271 public:
272         SHADER_NODE_CLASS(SubsurfaceScatteringNode)
273         bool has_surface_bssrdf() { return true; }
274 };
275
276 class EmissionNode : public ShaderNode {
277 public:
278         SHADER_NODE_CLASS(EmissionNode)
279
280         bool has_surface_emission() { return true; }
281
282         bool total_power;
283 };
284
285 class BackgroundNode : public ShaderNode {
286 public:
287         SHADER_NODE_CLASS(BackgroundNode)
288 };
289
290 class HoldoutNode : public ShaderNode {
291 public:
292         SHADER_NODE_CLASS(HoldoutNode)
293 };
294
295 class AmbientOcclusionNode : public ShaderNode {
296 public:
297         SHADER_NODE_CLASS(AmbientOcclusionNode)
298 };
299
300 class VolumeNode : public ShaderNode {
301 public:
302         SHADER_NODE_CLASS(VolumeNode)
303
304         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
305
306         ClosureType closure;
307 };
308
309 class TransparentVolumeNode : public VolumeNode {
310 public:
311         SHADER_NODE_CLASS(TransparentVolumeNode)
312 };
313
314 class IsotropicVolumeNode : public VolumeNode {
315 public:
316         SHADER_NODE_CLASS(IsotropicVolumeNode)
317 };
318
319 class GeometryNode : public ShaderNode {
320 public:
321         SHADER_NODE_CLASS(GeometryNode)
322         void attributes(AttributeRequestSet *attributes);
323 };
324
325 class TextureCoordinateNode : public ShaderNode {
326 public:
327         SHADER_NODE_CLASS(TextureCoordinateNode)
328         void attributes(AttributeRequestSet *attributes);
329         
330         bool from_dupli;
331 };
332
333 class LightPathNode : public ShaderNode {
334 public:
335         SHADER_NODE_CLASS(LightPathNode)
336 };
337
338 class LightFalloffNode : public ShaderNode {
339 public:
340         SHADER_NODE_CLASS(LightFalloffNode)
341 };
342
343 class ObjectInfoNode : public ShaderNode {
344 public:
345         SHADER_NODE_CLASS(ObjectInfoNode)
346 };
347
348 class ParticleInfoNode : public ShaderNode {
349 public:
350         SHADER_NODE_CLASS(ParticleInfoNode)
351         void attributes(AttributeRequestSet *attributes);
352 };
353
354 class HairInfoNode : public ShaderNode {
355 public:
356         SHADER_NODE_CLASS(HairInfoNode)
357
358         void attributes(AttributeRequestSet *attributes);
359 };
360
361 class ValueNode : public ShaderNode {
362 public:
363         SHADER_NODE_CLASS(ValueNode)
364
365         float value;
366 };
367
368 class ColorNode : public ShaderNode {
369 public:
370         SHADER_NODE_CLASS(ColorNode)
371
372         float3 value;
373 };
374
375 class AddClosureNode : public ShaderNode {
376 public:
377         SHADER_NODE_CLASS(AddClosureNode)
378 };
379
380 class MixClosureNode : public ShaderNode {
381 public:
382         SHADER_NODE_CLASS(MixClosureNode)
383 };
384
385 class MixClosureWeightNode : public ShaderNode {
386 public:
387         SHADER_NODE_CLASS(MixClosureWeightNode);
388 };
389
390 class InvertNode : public ShaderNode {
391 public:
392         SHADER_NODE_CLASS(InvertNode)
393 };
394
395 class MixNode : public ShaderNode {
396 public:
397         SHADER_NODE_CLASS(MixNode)
398
399         bool use_clamp;
400
401         ustring type;
402         static ShaderEnum type_enum;
403 };
404
405 class CombineRGBNode : public ShaderNode {
406 public:
407         SHADER_NODE_CLASS(CombineRGBNode)
408 };
409
410 class CombineHSVNode : public ShaderNode {
411 public:
412         SHADER_NODE_CLASS(CombineHSVNode)
413 };
414
415 class GammaNode : public ShaderNode {
416 public:
417         SHADER_NODE_CLASS(GammaNode)
418 };
419
420 class BrightContrastNode : public ShaderNode {
421 public:
422         SHADER_NODE_CLASS(BrightContrastNode)
423 };
424
425 class SeparateRGBNode : public ShaderNode {
426 public:
427         SHADER_NODE_CLASS(SeparateRGBNode)
428 };
429
430 class SeparateHSVNode : public ShaderNode {
431 public:
432         SHADER_NODE_CLASS(SeparateHSVNode)
433 };
434
435 class HSVNode : public ShaderNode {
436 public:
437         SHADER_NODE_CLASS(HSVNode)
438 };
439
440 class AttributeNode : public ShaderNode {
441 public:
442         SHADER_NODE_CLASS(AttributeNode)
443         void attributes(AttributeRequestSet *attributes);
444
445         ustring attribute;
446 };
447
448 class CameraNode : public ShaderNode {
449 public:
450         SHADER_NODE_CLASS(CameraNode)
451 };
452
453 class FresnelNode : public ShaderNode {
454 public:
455         SHADER_NODE_CLASS(FresnelNode)
456 };
457
458 class LayerWeightNode : public ShaderNode {
459 public:
460         SHADER_NODE_CLASS(LayerWeightNode)
461 };
462
463 class WireframeNode : public ShaderNode {
464 public:
465         SHADER_NODE_CLASS(WireframeNode)
466         
467         bool use_pixel_size;
468 };
469
470 class WavelengthNode : public ShaderNode {
471 public:
472         SHADER_NODE_CLASS(WavelengthNode)
473 };
474
475 class BlackbodyNode : public ShaderNode {
476 public:
477         SHADER_NODE_CLASS(BlackbodyNode)
478         
479         bool has_converter_blackbody() { return true; }
480 };
481
482 class MathNode : public ShaderNode {
483 public:
484         SHADER_NODE_CLASS(MathNode)
485
486         bool use_clamp;
487
488         ustring type;
489         static ShaderEnum type_enum;
490 };
491
492 class NormalNode : public ShaderNode {
493 public:
494         SHADER_NODE_CLASS(NormalNode)
495
496         float3 direction;
497 };
498
499 class VectorMathNode : public ShaderNode {
500 public:
501         SHADER_NODE_CLASS(VectorMathNode)
502
503         ustring type;
504         static ShaderEnum type_enum;
505 };
506
507 class VectorTransformNode : public ShaderNode {
508 public:
509         SHADER_NODE_CLASS(VectorTransformNode)
510
511         ustring type;
512         ustring convert_from;
513         ustring convert_to;
514         
515         static ShaderEnum type_enum;
516         static ShaderEnum convert_from_enum;
517         static ShaderEnum convert_to_enum;
518 };
519
520 class BumpNode : public ShaderNode {
521 public:
522         SHADER_NODE_CLASS(BumpNode)
523         bool invert;
524 };
525
526 class RGBCurvesNode : public ShaderNode {
527 public:
528         SHADER_NODE_CLASS(RGBCurvesNode)
529         float4 curves[RAMP_TABLE_SIZE];
530 };
531
532 class VectorCurvesNode : public ShaderNode {
533 public:
534         SHADER_NODE_CLASS(VectorCurvesNode)
535         float4 curves[RAMP_TABLE_SIZE];
536 };
537
538 class RGBRampNode : public ShaderNode {
539 public:
540         SHADER_NODE_CLASS(RGBRampNode)
541         float4 ramp[RAMP_TABLE_SIZE];
542         bool interpolate;
543 };
544
545 class SetNormalNode : public ShaderNode {
546 public:
547         SHADER_NODE_CLASS(SetNormalNode)
548 };
549
550 class OSLScriptNode : public ShaderNode {
551 public:
552         SHADER_NODE_CLASS(OSLScriptNode)
553         string filepath;
554         string bytecode_hash;
555         
556         /* ShaderInput/ShaderOutput only stores a shallow string copy (const char *)!
557          * The actual socket names have to be stored externally to avoid memory errors. */
558         vector<ustring> input_names;
559         vector<ustring> output_names;
560 };
561
562 class NormalMapNode : public ShaderNode {
563 public:
564         SHADER_NODE_CLASS(NormalMapNode)
565         void attributes(AttributeRequestSet *attributes);
566
567         ustring space;
568         static ShaderEnum space_enum;
569
570         ustring attribute;
571 };
572
573 class TangentNode : public ShaderNode {
574 public:
575         SHADER_NODE_CLASS(TangentNode)
576         void attributes(AttributeRequestSet *attributes);
577
578         ustring direction_type;
579         static ShaderEnum direction_type_enum;
580
581         ustring axis;
582         static ShaderEnum axis_enum;
583
584         ustring attribute;
585 };
586
587 CCL_NAMESPACE_END
588
589 #endif /* __NODES_H__ */
590