Cycles: Fold Value and RGB node as well.
[blender.git] / intern / cycles / render / nodes.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 __NODES_H__
18 #define __NODES_H__
19
20 #include "graph.h"
21
22 #include "util_string.h"
23
24 CCL_NAMESPACE_BEGIN
25
26 class ImageManager;
27 class Scene;
28 class Shader;
29
30 /* Texture Mapping */
31
32 class TextureMapping {
33 public:
34         TextureMapping();
35         Transform compute_transform();
36         bool skip();
37         void compile(SVMCompiler& compiler, int offset_in, int offset_out);
38         void compile(OSLCompiler &compiler);
39
40         float3 translation;
41         float3 rotation;
42         float3 scale;
43
44         float3 min, max;
45         bool use_minmax;
46
47         enum Type { POINT = 0, TEXTURE = 1, VECTOR = 2, NORMAL = 3 };
48         Type type;
49
50         enum Mapping { NONE = 0, X = 1, Y = 2, Z = 3 };
51         Mapping x_mapping, y_mapping, z_mapping;
52
53         enum Projection { FLAT, CUBE, TUBE, SPHERE };
54         Projection projection;
55 };
56
57 /* Nodes */
58
59 /* Any node which uses image manager's slot should be a subclass of this one. */
60 class ImageSlotNode : public ShaderNode {
61 public:
62         ImageSlotNode(const char *name_) : ShaderNode(name_) {
63                 special_type = SHADER_SPECIAL_TYPE_IMAGE_SLOT;
64         }
65         int slot;
66 };
67
68 class TextureNode : public ShaderNode {
69 public:
70         TextureNode(const char *name_) : ShaderNode(name_) {}
71         TextureMapping tex_mapping;
72 };
73
74 class ImageSlotTextureNode : public ImageSlotNode {
75 public:
76         ImageSlotTextureNode(const char *name_) : ImageSlotNode(name_) {}
77         TextureMapping tex_mapping;
78 };
79
80 class ImageTextureNode : public ImageSlotTextureNode {
81 public:
82         SHADER_NODE_NO_CLONE_CLASS(ImageTextureNode)
83         ~ImageTextureNode();
84         ShaderNode *clone() const;
85         void attributes(Shader *shader, AttributeRequestSet *attributes);
86
87         ImageManager *image_manager;
88         int is_float;
89         bool is_linear;
90         bool use_alpha;
91         string filename;
92         void *builtin_data;
93         ustring color_space;
94         ustring projection;
95         InterpolationType interpolation;
96         ExtensionType extension;
97         float projection_blend;
98         bool animated;
99
100         static ShaderEnum color_space_enum;
101         static ShaderEnum projection_enum;
102 };
103
104 class EnvironmentTextureNode : public ImageSlotTextureNode {
105 public:
106         SHADER_NODE_NO_CLONE_CLASS(EnvironmentTextureNode)
107         ~EnvironmentTextureNode();
108         ShaderNode *clone() const;
109         void attributes(Shader *shader, AttributeRequestSet *attributes);
110         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
111
112         ImageManager *image_manager;
113         int is_float;
114         bool is_linear;
115         bool use_alpha;
116         string filename;
117         void *builtin_data;
118         ustring color_space;
119         ustring projection;
120         InterpolationType interpolation;
121         bool animated;
122
123         static ShaderEnum color_space_enum;
124         static ShaderEnum projection_enum;
125 };
126
127 class SkyTextureNode : public TextureNode {
128 public:
129         SHADER_NODE_CLASS(SkyTextureNode)
130
131         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
132
133         float3 sun_direction;
134         float turbidity;
135         float ground_albedo;
136         
137         ustring type;
138         static ShaderEnum type_enum;
139 };
140
141 class OutputNode : public ShaderNode {
142 public:
143         SHADER_NODE_CLASS(OutputNode)
144 };
145
146 class GradientTextureNode : public TextureNode {
147 public:
148         SHADER_NODE_CLASS(GradientTextureNode)
149
150         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
151
152         ustring type;
153         static ShaderEnum type_enum;
154 };
155
156 class NoiseTextureNode : public TextureNode {
157 public:
158         SHADER_NODE_CLASS(NoiseTextureNode)
159 };
160
161 class VoronoiTextureNode : public TextureNode {
162 public:
163         SHADER_NODE_CLASS(VoronoiTextureNode)
164
165         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
166
167         ustring coloring;
168
169         static ShaderEnum coloring_enum;
170 };
171
172 class MusgraveTextureNode : public TextureNode {
173 public:
174         SHADER_NODE_CLASS(MusgraveTextureNode)
175
176         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
177
178         ustring type;
179
180         static ShaderEnum type_enum;
181 };
182
183 class WaveTextureNode : public TextureNode {
184 public:
185         SHADER_NODE_CLASS(WaveTextureNode)
186
187         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
188
189         ustring type;
190         static ShaderEnum type_enum;
191 };
192
193 class MagicTextureNode : public TextureNode {
194 public:
195         SHADER_NODE_CLASS(MagicTextureNode)
196
197         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
198
199         int depth;
200 };
201
202 class CheckerTextureNode : public TextureNode {
203 public:
204         SHADER_NODE_CLASS(CheckerTextureNode)
205
206         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
207 };
208
209 class BrickTextureNode : public TextureNode {
210 public:
211         SHADER_NODE_CLASS(BrickTextureNode)
212         
213         float offset, squash;
214         int offset_frequency, squash_frequency;
215
216         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
217 };
218
219 class PointDensityTextureNode : public ShaderNode {
220 public:
221         SHADER_NODE_NO_CLONE_CLASS(PointDensityTextureNode)
222
223         ~PointDensityTextureNode();
224         ShaderNode *clone() const;
225         void attributes(Shader *shader, AttributeRequestSet *attributes);
226
227         bool has_spatial_varying() { return true; }
228         bool has_object_dependency() { return true; }
229
230         ImageManager *image_manager;
231         int slot;
232         string filename;
233         ustring space;
234         void *builtin_data;
235         InterpolationType interpolation;
236
237         Transform tfm;
238
239         static ShaderEnum space_enum;
240 };
241
242 class MappingNode : public ShaderNode {
243 public:
244         SHADER_NODE_CLASS(MappingNode)
245         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
246
247         TextureMapping tex_mapping;
248 };
249
250 class ConvertNode : public ShaderNode {
251 public:
252         ConvertNode(ShaderSocketType from, ShaderSocketType to, bool autoconvert = false);
253         SHADER_NODE_BASE_CLASS(ConvertNode)
254
255         ShaderSocketType from, to;
256 };
257
258 class ProxyNode : public ShaderNode {
259 public:
260         ProxyNode(ShaderSocketType type);
261         SHADER_NODE_BASE_CLASS(ProxyNode)
262
263         ShaderSocketType type;
264 };
265
266 class BsdfNode : public ShaderNode {
267 public:
268         BsdfNode(bool scattering = false);
269         SHADER_NODE_BASE_CLASS(BsdfNode);
270
271         bool has_spatial_varying() { return true; }
272         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2, ShaderInput *param3 = NULL, ShaderInput *param4 = NULL);
273
274         ClosureType closure;
275         bool scattering;
276 };
277
278 class AnisotropicBsdfNode : public BsdfNode {
279 public:
280         SHADER_NODE_CLASS(AnisotropicBsdfNode)
281
282         ustring distribution;
283         static ShaderEnum distribution_enum;
284
285         void attributes(Shader *shader, AttributeRequestSet *attributes);
286 };
287
288 class DiffuseBsdfNode : public BsdfNode {
289 public:
290         SHADER_NODE_CLASS(DiffuseBsdfNode)
291 };
292
293 class TranslucentBsdfNode : public BsdfNode {
294 public:
295         SHADER_NODE_CLASS(TranslucentBsdfNode)
296 };
297
298 class TransparentBsdfNode : public BsdfNode {
299 public:
300         SHADER_NODE_CLASS(TransparentBsdfNode)
301
302         bool has_surface_transparent() { return true; }
303 };
304
305 class VelvetBsdfNode : public BsdfNode {
306 public:
307         SHADER_NODE_CLASS(VelvetBsdfNode)
308 };
309
310 class GlossyBsdfNode : public BsdfNode {
311 public:
312         SHADER_NODE_CLASS(GlossyBsdfNode)
313
314         void simplify_settings(Scene *scene);
315         bool has_integrator_dependency();
316
317         ustring distribution, distribution_orig;
318         static ShaderEnum distribution_enum;
319 };
320
321 class GlassBsdfNode : public BsdfNode {
322 public:
323         SHADER_NODE_CLASS(GlassBsdfNode)
324
325         void simplify_settings(Scene *scene);
326         bool has_integrator_dependency();
327
328         ustring distribution, distribution_orig;
329         static ShaderEnum distribution_enum;
330 };
331
332 class RefractionBsdfNode : public BsdfNode {
333 public:
334         SHADER_NODE_CLASS(RefractionBsdfNode)
335
336         void simplify_settings(Scene *scene);
337         bool has_integrator_dependency();
338
339         ustring distribution, distribution_orig;
340         static ShaderEnum distribution_enum;
341 };
342
343 class ToonBsdfNode : public BsdfNode {
344 public:
345         SHADER_NODE_CLASS(ToonBsdfNode)
346
347         ustring component;
348         static ShaderEnum component_enum;
349 };
350
351 class SubsurfaceScatteringNode : public BsdfNode {
352 public:
353         SHADER_NODE_CLASS(SubsurfaceScatteringNode)
354         bool has_surface_bssrdf() { return true; }
355         bool has_bssrdf_bump();
356         bool has_spatial_varying() { return true; }
357
358         static ShaderEnum falloff_enum;
359 };
360
361 class EmissionNode : public ShaderNode {
362 public:
363         SHADER_NODE_CLASS(EmissionNode)
364
365         bool has_surface_emission() { return true; }
366         bool has_spatial_varying() { return true; }
367 };
368
369 class BackgroundNode : public ShaderNode {
370 public:
371         SHADER_NODE_CLASS(BackgroundNode)
372 };
373
374 class HoldoutNode : public ShaderNode {
375 public:
376         SHADER_NODE_CLASS(HoldoutNode)
377         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
378 };
379
380 class AmbientOcclusionNode : public ShaderNode {
381 public:
382         SHADER_NODE_CLASS(AmbientOcclusionNode)
383
384         bool has_spatial_varying() { return true; }
385         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
386 };
387
388 class VolumeNode : public ShaderNode {
389 public:
390         SHADER_NODE_CLASS(VolumeNode)
391
392         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
393         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
394
395         ClosureType closure;
396 };
397
398 class AbsorptionVolumeNode : public VolumeNode {
399 public:
400         SHADER_NODE_CLASS(AbsorptionVolumeNode)
401 };
402
403 class ScatterVolumeNode : public VolumeNode {
404 public:
405         SHADER_NODE_CLASS(ScatterVolumeNode)
406 };
407
408 class HairBsdfNode : public BsdfNode {
409 public:
410         SHADER_NODE_CLASS(HairBsdfNode)
411
412         ustring component;
413         static ShaderEnum component_enum;
414
415 };
416
417 class GeometryNode : public ShaderNode {
418 public:
419         SHADER_NODE_CLASS(GeometryNode)
420         void attributes(Shader *shader, AttributeRequestSet *attributes);
421         bool has_spatial_varying() { return true; }
422 };
423
424 class TextureCoordinateNode : public ShaderNode {
425 public:
426         SHADER_NODE_CLASS(TextureCoordinateNode)
427         void attributes(Shader *shader, AttributeRequestSet *attributes);
428         bool has_spatial_varying() { return true; }
429         bool has_object_dependency() { return use_transform; }
430
431         bool from_dupli;
432         bool use_transform;
433         Transform ob_tfm;
434 };
435
436 class UVMapNode : public ShaderNode {
437 public:
438         SHADER_NODE_CLASS(UVMapNode)
439         void attributes(Shader *shader, AttributeRequestSet *attributes);
440         bool has_spatial_varying() { return true; }
441         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
442
443         ustring attribute;
444         bool from_dupli;
445 };
446
447 class LightPathNode : public ShaderNode {
448 public:
449         SHADER_NODE_CLASS(LightPathNode)
450         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
451 };
452
453 class LightFalloffNode : public ShaderNode {
454 public:
455         SHADER_NODE_CLASS(LightFalloffNode)
456         bool has_spatial_varying() { return true; }
457 };
458
459 class ObjectInfoNode : public ShaderNode {
460 public:
461         SHADER_NODE_CLASS(ObjectInfoNode)
462         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
463 };
464
465 class ParticleInfoNode : public ShaderNode {
466 public:
467         SHADER_NODE_CLASS(ParticleInfoNode)
468         void attributes(Shader *shader, AttributeRequestSet *attributes);
469         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
470 };
471
472 class HairInfoNode : public ShaderNode {
473 public:
474         SHADER_NODE_CLASS(HairInfoNode)
475
476         void attributes(Shader *shader, AttributeRequestSet *attributes);
477         bool has_spatial_varying() { return true; }
478         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
479         virtual int get_feature() {
480                 return ShaderNode::get_feature() | NODE_FEATURE_HAIR;
481         }
482 };
483
484 class ValueNode : public ShaderNode {
485 public:
486         SHADER_NODE_CLASS(ValueNode)
487
488         bool constant_fold(ShaderOutput *socket, float3 *optimized_value);
489
490         float value;
491 };
492
493 class ColorNode : public ShaderNode {
494 public:
495         SHADER_NODE_CLASS(ColorNode)
496
497         bool constant_fold(ShaderOutput *socket, float3 *optimized_value);
498
499         float3 value;
500 };
501
502 class AddClosureNode : public ShaderNode {
503 public:
504         SHADER_NODE_CLASS(AddClosureNode)
505 };
506
507 class MixClosureNode : public ShaderNode {
508 public:
509         SHADER_NODE_CLASS(MixClosureNode)
510 };
511
512 class MixClosureWeightNode : public ShaderNode {
513 public:
514         SHADER_NODE_CLASS(MixClosureWeightNode);
515 };
516
517 class InvertNode : public ShaderNode {
518 public:
519         SHADER_NODE_CLASS(InvertNode)
520
521         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
522 };
523
524 class MixNode : public ShaderNode {
525 public:
526         SHADER_NODE_CLASS(MixNode)
527
528         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
529
530         bool use_clamp;
531
532         ustring type;
533         static ShaderEnum type_enum;
534 };
535
536 class CombineRGBNode : public ShaderNode {
537 public:
538         SHADER_NODE_CLASS(CombineRGBNode)
539
540         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
541 };
542
543 class CombineHSVNode : public ShaderNode {
544 public:
545         SHADER_NODE_CLASS(CombineHSVNode)
546
547         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
548 };
549
550 class CombineXYZNode : public ShaderNode {
551 public:
552         SHADER_NODE_CLASS(CombineXYZNode)
553
554         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
555 };
556
557 class GammaNode : public ShaderNode {
558 public:
559         SHADER_NODE_CLASS(GammaNode)
560         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
561 };
562
563 class BrightContrastNode : public ShaderNode {
564 public:
565         SHADER_NODE_CLASS(BrightContrastNode)
566         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
567 };
568
569 class SeparateRGBNode : public ShaderNode {
570 public:
571         SHADER_NODE_CLASS(SeparateRGBNode)
572
573         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
574 };
575
576 class SeparateHSVNode : public ShaderNode {
577 public:
578         SHADER_NODE_CLASS(SeparateHSVNode)
579
580         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
581 };
582
583 class SeparateXYZNode : public ShaderNode {
584 public:
585         SHADER_NODE_CLASS(SeparateXYZNode)
586
587         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
588 };
589
590 class HSVNode : public ShaderNode {
591 public:
592         SHADER_NODE_CLASS(HSVNode)
593 };
594
595 class AttributeNode : public ShaderNode {
596 public:
597         SHADER_NODE_CLASS(AttributeNode)
598         void attributes(Shader *shader, AttributeRequestSet *attributes);
599         bool has_spatial_varying() { return true; }
600
601         ustring attribute;
602 };
603
604 class CameraNode : public ShaderNode {
605 public:
606         SHADER_NODE_CLASS(CameraNode)
607         bool has_spatial_varying() { return true; }
608 };
609
610 class FresnelNode : public ShaderNode {
611 public:
612         SHADER_NODE_CLASS(FresnelNode)
613         bool has_spatial_varying() { return true; }
614         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
615 };
616
617 class LayerWeightNode : public ShaderNode {
618 public:
619         SHADER_NODE_CLASS(LayerWeightNode)
620         bool has_spatial_varying() { return true; }
621         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
622 };
623
624 class WireframeNode : public ShaderNode {
625 public:
626         SHADER_NODE_CLASS(WireframeNode)
627         bool has_spatial_varying() { return true; }
628         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
629         
630         bool use_pixel_size;
631 };
632
633 class WavelengthNode : public ShaderNode {
634 public:
635         SHADER_NODE_CLASS(WavelengthNode)
636
637         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
638 };
639
640 class BlackbodyNode : public ShaderNode {
641 public:
642         SHADER_NODE_CLASS(BlackbodyNode)
643         bool constant_fold(ShaderOutput *socket, float3 *optimized_value);
644
645         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
646 };
647
648 class MathNode : public ShaderNode {
649 public:
650         SHADER_NODE_CLASS(MathNode)
651         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
652         bool constant_fold(ShaderOutput *socket, float3 *optimized_value);
653
654         bool use_clamp;
655
656         ustring type;
657         static ShaderEnum type_enum;
658 };
659
660 class NormalNode : public ShaderNode {
661 public:
662         SHADER_NODE_CLASS(NormalNode)
663         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
664
665         float3 direction;
666 };
667
668 class VectorMathNode : public ShaderNode {
669 public:
670         SHADER_NODE_CLASS(VectorMathNode)
671         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
672         bool constant_fold(ShaderOutput *socket, float3 *optimized_value);
673
674         ustring type;
675         static ShaderEnum type_enum;
676 };
677
678 class VectorTransformNode : public ShaderNode {
679 public:
680         SHADER_NODE_CLASS(VectorTransformNode)
681
682         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
683
684         ustring type;
685         ustring convert_from;
686         ustring convert_to;
687         
688         static ShaderEnum type_enum;
689         static ShaderEnum convert_space_enum;
690 };
691
692 class BumpNode : public ShaderNode {
693 public:
694         SHADER_NODE_CLASS(BumpNode)
695         bool has_spatial_varying() { return true; }
696         virtual int get_feature() {
697                 return NODE_FEATURE_BUMP;
698         }
699
700         bool invert;
701 };
702
703 class RGBCurvesNode : public ShaderNode {
704 public:
705         SHADER_NODE_CLASS(RGBCurvesNode)
706
707         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
708
709         float4 curves[RAMP_TABLE_SIZE];
710         float min_x, max_x;
711 };
712
713 class VectorCurvesNode : public ShaderNode {
714 public:
715         SHADER_NODE_CLASS(VectorCurvesNode)
716
717         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
718
719         float4 curves[RAMP_TABLE_SIZE];
720 };
721
722 class RGBRampNode : public ShaderNode {
723 public:
724         SHADER_NODE_CLASS(RGBRampNode)
725         float4 ramp[RAMP_TABLE_SIZE];
726         bool interpolate;
727         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
728 };
729
730 class SetNormalNode : public ShaderNode {
731 public:
732         SHADER_NODE_CLASS(SetNormalNode)
733 };
734
735 class OSLScriptNode : public ShaderNode {
736 public:
737         SHADER_NODE_CLASS(OSLScriptNode)
738
739         /* ideally we could beter detect this, but we can't query this now */
740         bool has_spatial_varying() { return true; }
741
742         string filepath;
743         string bytecode_hash;
744         
745         /* ShaderInput/ShaderOutput only stores a shallow string copy (const char *)!
746          * The actual socket names have to be stored externally to avoid memory errors. */
747         vector<ustring> input_names;
748         vector<ustring> output_names;
749 };
750
751 class NormalMapNode : public ShaderNode {
752 public:
753         SHADER_NODE_CLASS(NormalMapNode)
754         void attributes(Shader *shader, AttributeRequestSet *attributes);
755         bool has_spatial_varying() { return true; }
756         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
757
758         ustring space;
759         static ShaderEnum space_enum;
760
761         ustring attribute;
762 };
763
764 class TangentNode : public ShaderNode {
765 public:
766         SHADER_NODE_CLASS(TangentNode)
767         void attributes(Shader *shader, AttributeRequestSet *attributes);
768         bool has_spatial_varying() { return true; }
769         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
770
771         ustring direction_type;
772         static ShaderEnum direction_type_enum;
773
774         ustring axis;
775         static ShaderEnum axis_enum;
776
777         ustring attribute;
778 };
779
780 CCL_NAMESPACE_END
781
782 #endif /* __NODES_H__ */
783