Cycles: Remove meaningless volume shaders
[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 "render/graph.h"
21 #include "graph/node.h"
22
23 #include "util/util_string.h"
24
25 CCL_NAMESPACE_BEGIN
26
27 class ImageManager;
28 class Scene;
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         int compile(SVMCompiler& compiler, ShaderInput *vector_in);
40         void compile(OSLCompiler &compiler);
41
42         int compile_begin(SVMCompiler& compiler, ShaderInput *vector_in);
43         void compile_end(SVMCompiler& compiler, ShaderInput *vector_in, int vector_offset);
44
45         float3 translation;
46         float3 rotation;
47         float3 scale;
48
49         float3 min, max;
50         bool use_minmax;
51
52         enum Type { POINT = 0, TEXTURE = 1, VECTOR = 2, NORMAL = 3 };
53         Type type;
54
55         enum Mapping { NONE = 0, X = 1, Y = 2, Z = 3 };
56         Mapping x_mapping, y_mapping, z_mapping;
57
58         enum Projection { FLAT, CUBE, TUBE, SPHERE };
59         Projection projection;
60 };
61
62 /* Nodes */
63
64 class TextureNode : public ShaderNode {
65 public:
66         explicit TextureNode(const NodeType *node_type) : ShaderNode(node_type) {}
67         TextureMapping tex_mapping;
68 };
69
70 /* Any node which uses image manager's slot should be a subclass of this one. */
71 class ImageSlotTextureNode : public TextureNode {
72 public:
73         explicit ImageSlotTextureNode(const NodeType *node_type) : TextureNode(node_type) {
74                 special_type = SHADER_SPECIAL_TYPE_IMAGE_SLOT;
75         }
76         int slot;
77 };
78
79 class ImageTextureNode : public ImageSlotTextureNode {
80 public:
81         SHADER_NODE_NO_CLONE_CLASS(ImageTextureNode)
82         ~ImageTextureNode();
83         ShaderNode *clone() const;
84         void attributes(Shader *shader, AttributeRequestSet *attributes);
85
86         ImageManager *image_manager;
87         int is_float;
88         bool is_linear;
89         bool use_alpha;
90         ustring filename;
91         void *builtin_data;
92         NodeImageColorSpace color_space;
93         NodeImageProjection projection;
94         InterpolationType interpolation;
95         ExtensionType extension;
96         float projection_blend;
97         bool animated;
98         float3 vector;
99
100         virtual bool equals(const ShaderNode& other)
101         {
102                 const ImageTextureNode& image_node = (const ImageTextureNode&)other;
103                 return ImageSlotTextureNode::equals(other) &&
104                        builtin_data == image_node.builtin_data &&
105                        animated == image_node.animated;
106         }
107 };
108
109 class EnvironmentTextureNode : public ImageSlotTextureNode {
110 public:
111         SHADER_NODE_NO_CLONE_CLASS(EnvironmentTextureNode)
112         ~EnvironmentTextureNode();
113         ShaderNode *clone() const;
114         void attributes(Shader *shader, AttributeRequestSet *attributes);
115         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
116
117         ImageManager *image_manager;
118         int is_float;
119         bool is_linear;
120         bool use_alpha;
121         ustring filename;
122         void *builtin_data;
123         NodeImageColorSpace color_space;
124         NodeEnvironmentProjection projection;
125         InterpolationType interpolation;
126         bool animated;
127         float3 vector;
128
129         virtual bool equals(const ShaderNode& other)
130         {
131                 const EnvironmentTextureNode& env_node = (const EnvironmentTextureNode&)other;
132                 return ImageSlotTextureNode::equals(other) &&
133                        builtin_data == env_node.builtin_data &&
134                        animated == env_node.animated;
135         }
136 };
137
138 class SkyTextureNode : public TextureNode {
139 public:
140         SHADER_NODE_CLASS(SkyTextureNode)
141
142         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
143
144         NodeSkyType type;
145         float3 sun_direction;
146         float turbidity;
147         float ground_albedo;
148         float3 vector;
149 };
150
151 class OutputNode : public ShaderNode {
152 public:
153         SHADER_NODE_CLASS(OutputNode)
154
155         void *surface;
156         void *volume;
157         float displacement;
158         float3 normal;
159
160         /* Don't allow output node de-duplication. */
161         virtual bool equals(const ShaderNode& /*other*/) { return false; }
162 };
163
164 class GradientTextureNode : public TextureNode {
165 public:
166         SHADER_NODE_CLASS(GradientTextureNode)
167
168         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
169
170         NodeGradientType type;
171         float3 vector;
172 };
173
174 class NoiseTextureNode : public TextureNode {
175 public:
176         SHADER_NODE_CLASS(NoiseTextureNode)
177
178         float scale, detail, distortion;
179         float3 vector;
180 };
181
182 class VoronoiTextureNode : public TextureNode {
183 public:
184         SHADER_NODE_CLASS(VoronoiTextureNode)
185
186         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
187
188         NodeVoronoiColoring coloring;
189         float scale;
190         float3 vector;
191 };
192
193 class MusgraveTextureNode : public TextureNode {
194 public:
195         SHADER_NODE_CLASS(MusgraveTextureNode)
196
197         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
198
199         NodeMusgraveType type;
200         float scale, detail, dimension, lacunarity, offset, gain;
201         float3 vector;
202 };
203
204 class WaveTextureNode : public TextureNode {
205 public:
206         SHADER_NODE_CLASS(WaveTextureNode)
207
208         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
209
210         NodeWaveType type;
211         NodeWaveProfile profile;
212
213         float scale, distortion, detail, detail_scale;
214         float3 vector;
215 };
216
217 class MagicTextureNode : public TextureNode {
218 public:
219         SHADER_NODE_CLASS(MagicTextureNode)
220
221         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
222
223         int depth;
224         float3 vector;
225         float scale, distortion;
226 };
227
228 class CheckerTextureNode : public TextureNode {
229 public:
230         SHADER_NODE_CLASS(CheckerTextureNode)
231
232         float3 vector, color1, color2;
233         float scale;
234
235         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
236 };
237
238 class BrickTextureNode : public TextureNode {
239 public:
240         SHADER_NODE_CLASS(BrickTextureNode)
241
242         float offset, squash;
243         int offset_frequency, squash_frequency;
244
245         float3 color1, color2, mortar;
246         float scale, mortar_size, mortar_smooth, bias, brick_width, row_height;
247         float3 vector;
248
249         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
250 };
251
252 class PointDensityTextureNode : public ShaderNode {
253 public:
254         SHADER_NODE_NO_CLONE_CLASS(PointDensityTextureNode)
255
256         ~PointDensityTextureNode();
257         ShaderNode *clone() const;
258         void attributes(Shader *shader, AttributeRequestSet *attributes);
259
260         bool has_spatial_varying() { return true; }
261         bool has_object_dependency() { return true; }
262
263         ustring filename;
264         NodeTexVoxelSpace space;
265         InterpolationType interpolation;
266         Transform tfm;
267         float3 vector;
268
269         ImageManager *image_manager;
270         int slot;
271         void *builtin_data;
272
273         virtual bool equals(const ShaderNode& other) {
274                 const PointDensityTextureNode& point_dendity_node = (const PointDensityTextureNode&)other;
275                 return ShaderNode::equals(other) &&
276                        builtin_data == point_dendity_node.builtin_data;
277         }
278 };
279
280 class MappingNode : public ShaderNode {
281 public:
282         SHADER_NODE_CLASS(MappingNode)
283         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
284
285         float3 vector;
286         TextureMapping tex_mapping;
287 };
288
289 class RGBToBWNode : public ShaderNode {
290 public:
291         SHADER_NODE_CLASS(RGBToBWNode)
292         void constant_fold(const ConstantFolder& folder);
293
294         float3 color;
295 };
296
297 class ConvertNode : public ShaderNode {
298 public:
299         ConvertNode(SocketType::Type from, SocketType::Type to, bool autoconvert = false);
300         SHADER_NODE_BASE_CLASS(ConvertNode)
301
302         void constant_fold(const ConstantFolder& folder);
303
304         SocketType::Type from, to;
305
306         union {
307                 float value_float;
308                 int value_int;
309                 float3 value_color;
310                 float3 value_vector;
311                 float3 value_point;
312                 float3 value_normal;
313         };
314         ustring value_string;
315
316 private:
317         static const int MAX_TYPE = 12;
318         static bool register_types();
319         static Node* create(const NodeType *type);
320         static const NodeType *node_types[MAX_TYPE][MAX_TYPE];
321         static bool initialized;
322 };
323
324 class BsdfNode : public ShaderNode {
325 public:
326         explicit BsdfNode(const NodeType *node_type);
327         SHADER_NODE_BASE_CLASS(BsdfNode)
328
329         bool has_spatial_varying() { return true; }
330         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2, ShaderInput *param3 = NULL, ShaderInput *param4 = NULL);
331         virtual ClosureType get_closure_type() { return closure; }
332
333         float3 color;
334         float3 normal;
335         float surface_mix_weight;
336         ClosureType closure;
337
338         virtual bool equals(const ShaderNode& /*other*/)
339         {
340                 /* TODO(sergey): With some care BSDF nodes can be de-duplicated. */
341                 return false;
342         }
343 };
344
345 class AnisotropicBsdfNode : public BsdfNode {
346 public:
347         SHADER_NODE_CLASS(AnisotropicBsdfNode)
348
349         float3 tangent;
350         float roughness, anisotropy, rotation;
351         ClosureType distribution;
352
353         ClosureType get_closure_type() { return distribution; }
354         void attributes(Shader *shader, AttributeRequestSet *attributes);
355 };
356
357 class DiffuseBsdfNode : public BsdfNode {
358 public:
359         SHADER_NODE_CLASS(DiffuseBsdfNode)
360
361         float roughness;
362 };
363
364 class TranslucentBsdfNode : public BsdfNode {
365 public:
366         SHADER_NODE_CLASS(TranslucentBsdfNode)
367 };
368
369 class TransparentBsdfNode : public BsdfNode {
370 public:
371         SHADER_NODE_CLASS(TransparentBsdfNode)
372
373         bool has_surface_transparent() { return true; }
374 };
375
376 class VelvetBsdfNode : public BsdfNode {
377 public:
378         SHADER_NODE_CLASS(VelvetBsdfNode)
379
380         float sigma;
381 };
382
383 class GlossyBsdfNode : public BsdfNode {
384 public:
385         SHADER_NODE_CLASS(GlossyBsdfNode)
386
387         void simplify_settings(Scene *scene);
388         bool has_integrator_dependency();
389         ClosureType get_closure_type() { return distribution; }
390
391         float roughness, roughness_orig;
392         ClosureType distribution, distribution_orig;
393 };
394
395 class GlassBsdfNode : public BsdfNode {
396 public:
397         SHADER_NODE_CLASS(GlassBsdfNode)
398
399         void simplify_settings(Scene *scene);
400         bool has_integrator_dependency();
401         ClosureType get_closure_type() { return distribution; }
402
403         float roughness, roughness_orig, IOR;
404         ClosureType distribution, distribution_orig;
405 };
406
407 class RefractionBsdfNode : public BsdfNode {
408 public:
409         SHADER_NODE_CLASS(RefractionBsdfNode)
410
411         void simplify_settings(Scene *scene);
412         bool has_integrator_dependency();
413         ClosureType get_closure_type() { return distribution; }
414
415         float roughness, roughness_orig, IOR;
416         ClosureType distribution, distribution_orig;
417 };
418
419 class ToonBsdfNode : public BsdfNode {
420 public:
421         SHADER_NODE_CLASS(ToonBsdfNode)
422
423         float smooth, size;
424         ClosureType component;
425 };
426
427 class SubsurfaceScatteringNode : public BsdfNode {
428 public:
429         SHADER_NODE_CLASS(SubsurfaceScatteringNode)
430         bool has_surface_bssrdf() { return true; }
431         bool has_bssrdf_bump();
432         ClosureType get_closure_type() { return falloff; }
433
434         float scale;
435         float3 radius;
436         float sharpness;
437         float texture_blur;
438         ClosureType falloff;
439 };
440
441 class EmissionNode : public ShaderNode {
442 public:
443         SHADER_NODE_CLASS(EmissionNode)
444         void constant_fold(const ConstantFolder& folder);
445         virtual ClosureType get_closure_type() { return CLOSURE_EMISSION_ID; }
446
447         bool has_surface_emission() { return true; }
448         bool has_volume_support() { return true; }
449
450         float3 color;
451         float strength;
452         float surface_mix_weight;
453 };
454
455 class BackgroundNode : public ShaderNode {
456 public:
457         SHADER_NODE_CLASS(BackgroundNode)
458         void constant_fold(const ConstantFolder& folder);
459         virtual ClosureType get_closure_type() { return CLOSURE_BACKGROUND_ID; }
460
461         float3 color;
462         float strength;
463         float surface_mix_weight;
464 };
465
466 class HoldoutNode : public ShaderNode {
467 public:
468         SHADER_NODE_CLASS(HoldoutNode)
469         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
470         virtual ClosureType get_closure_type() { return CLOSURE_HOLDOUT_ID; }
471
472         float surface_mix_weight;
473         float volume_mix_weight;
474 };
475
476 class AmbientOcclusionNode : public ShaderNode {
477 public:
478         SHADER_NODE_CLASS(AmbientOcclusionNode)
479
480         bool has_spatial_varying() { return true; }
481         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
482         virtual ClosureType get_closure_type() { return CLOSURE_AMBIENT_OCCLUSION_ID; }
483
484         float3 normal_osl;
485         float3 color;
486         float surface_mix_weight;
487 };
488
489 class VolumeNode : public ShaderNode {
490 public:
491         VolumeNode(const NodeType *node_type);
492         SHADER_NODE_BASE_CLASS(VolumeNode)
493
494         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
495         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
496         virtual int get_feature() {
497                 return ShaderNode::get_feature() | NODE_FEATURE_VOLUME;
498         }
499         virtual ClosureType get_closure_type() { return closure; }
500         virtual bool has_volume_support() { return true; }
501
502         float3 color;
503         float density;
504         float volume_mix_weight;
505         ClosureType closure;
506
507         virtual bool equals(const ShaderNode& /*other*/)
508         {
509                 /* TODO(sergey): With some care Volume nodes can be de-duplicated. */
510                 return false;
511         }
512 };
513
514 class AbsorptionVolumeNode : public VolumeNode {
515 public:
516         SHADER_NODE_CLASS(AbsorptionVolumeNode)
517 };
518
519 class ScatterVolumeNode : public VolumeNode {
520 public:
521         SHADER_NODE_CLASS(ScatterVolumeNode)
522
523         float anisotropy;
524 };
525
526 class HairBsdfNode : public BsdfNode {
527 public:
528         SHADER_NODE_CLASS(HairBsdfNode)
529         ClosureType get_closure_type() { return component; }
530
531         ClosureType component;
532         float offset;
533         float roughness_u;
534         float roughness_v;
535         float3 tangent;
536 };
537
538 class GeometryNode : public ShaderNode {
539 public:
540         SHADER_NODE_CLASS(GeometryNode)
541         void attributes(Shader *shader, AttributeRequestSet *attributes);
542         bool has_spatial_varying() { return true; }
543
544         float3 normal_osl;
545 };
546
547 class TextureCoordinateNode : public ShaderNode {
548 public:
549         SHADER_NODE_CLASS(TextureCoordinateNode)
550         void attributes(Shader *shader, AttributeRequestSet *attributes);
551         bool has_spatial_varying() { return true; }
552         bool has_object_dependency() { return use_transform; }
553
554         float3 normal_osl;
555         bool from_dupli;
556         bool use_transform;
557         Transform ob_tfm;
558 };
559
560 class UVMapNode : public ShaderNode {
561 public:
562         SHADER_NODE_CLASS(UVMapNode)
563         void attributes(Shader *shader, AttributeRequestSet *attributes);
564         bool has_spatial_varying() { return true; }
565         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
566
567         ustring attribute;
568         bool from_dupli;
569 };
570
571 class LightPathNode : public ShaderNode {
572 public:
573         SHADER_NODE_CLASS(LightPathNode)
574         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
575 };
576
577 class LightFalloffNode : public ShaderNode {
578 public:
579         SHADER_NODE_CLASS(LightFalloffNode)
580         bool has_spatial_varying() { return true; }
581         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
582
583         float strength;
584         float smooth;
585 };
586
587 class ObjectInfoNode : public ShaderNode {
588 public:
589         SHADER_NODE_CLASS(ObjectInfoNode)
590         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
591 };
592
593 class ParticleInfoNode : public ShaderNode {
594 public:
595         SHADER_NODE_CLASS(ParticleInfoNode)
596         void attributes(Shader *shader, AttributeRequestSet *attributes);
597         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
598 };
599
600 class HairInfoNode : public ShaderNode {
601 public:
602         SHADER_NODE_CLASS(HairInfoNode)
603
604         void attributes(Shader *shader, AttributeRequestSet *attributes);
605         bool has_spatial_varying() { return true; }
606         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
607         virtual int get_feature() {
608                 return ShaderNode::get_feature() | NODE_FEATURE_HAIR;
609         }
610 };
611
612 class ValueNode : public ShaderNode {
613 public:
614         SHADER_NODE_CLASS(ValueNode)
615
616         void constant_fold(const ConstantFolder& folder);
617
618         float value;
619 };
620
621 class ColorNode : public ShaderNode {
622 public:
623         SHADER_NODE_CLASS(ColorNode)
624
625         void constant_fold(const ConstantFolder& folder);
626
627         float3 value;
628 };
629
630 class AddClosureNode : public ShaderNode {
631 public:
632         SHADER_NODE_CLASS(AddClosureNode)
633         void constant_fold(const ConstantFolder& folder);
634 };
635
636 class MixClosureNode : public ShaderNode {
637 public:
638         SHADER_NODE_CLASS(MixClosureNode)
639         void constant_fold(const ConstantFolder& folder);
640
641         float fac;
642 };
643
644 class MixClosureWeightNode : public ShaderNode {
645 public:
646         SHADER_NODE_CLASS(MixClosureWeightNode)
647
648         float weight;
649         float fac;
650 };
651
652 class InvertNode : public ShaderNode {
653 public:
654         SHADER_NODE_CLASS(InvertNode)
655         void constant_fold(const ConstantFolder& folder);
656         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
657
658         float fac;
659         float3 color;
660 };
661
662 class MixNode : public ShaderNode {
663 public:
664         SHADER_NODE_CLASS(MixNode)
665         void constant_fold(const ConstantFolder& folder);
666
667         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
668
669         NodeMix type;
670         bool use_clamp;
671         float3 color1;
672         float3 color2;
673         float fac;
674 };
675
676 class CombineRGBNode : public ShaderNode {
677 public:
678         SHADER_NODE_CLASS(CombineRGBNode)
679         void constant_fold(const ConstantFolder& folder);
680         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
681
682         float r, g, b;
683 };
684
685 class CombineHSVNode : public ShaderNode {
686 public:
687         SHADER_NODE_CLASS(CombineHSVNode)
688         void constant_fold(const ConstantFolder& folder);
689         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
690
691         float h, s, v;
692 };
693
694 class CombineXYZNode : public ShaderNode {
695 public:
696         SHADER_NODE_CLASS(CombineXYZNode)
697         void constant_fold(const ConstantFolder& folder);
698         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
699
700         float x, y, z;
701 };
702
703 class GammaNode : public ShaderNode {
704 public:
705         SHADER_NODE_CLASS(GammaNode)
706         void constant_fold(const ConstantFolder& folder);
707         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
708
709         float3 color;
710         float gamma;
711 };
712
713 class BrightContrastNode : public ShaderNode {
714 public:
715         SHADER_NODE_CLASS(BrightContrastNode)
716         void constant_fold(const ConstantFolder& folder);
717         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
718
719         float3 color;
720         float bright;
721         float contrast;
722 };
723
724 class SeparateRGBNode : public ShaderNode {
725 public:
726         SHADER_NODE_CLASS(SeparateRGBNode)
727         void constant_fold(const ConstantFolder& folder);
728         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
729
730         float3 color;
731 };
732
733 class SeparateHSVNode : public ShaderNode {
734 public:
735         SHADER_NODE_CLASS(SeparateHSVNode)
736         void constant_fold(const ConstantFolder& folder);
737         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
738
739         float3 color;
740 };
741
742 class SeparateXYZNode : public ShaderNode {
743 public:
744         SHADER_NODE_CLASS(SeparateXYZNode)
745         void constant_fold(const ConstantFolder& folder);
746         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
747
748         float3 vector;
749 };
750
751 class HSVNode : public ShaderNode {
752 public:
753         SHADER_NODE_CLASS(HSVNode)
754
755         float hue;
756         float saturation;
757         float value;
758         float fac;
759         float3 color;
760 };
761
762 class AttributeNode : public ShaderNode {
763 public:
764         SHADER_NODE_CLASS(AttributeNode)
765         void attributes(Shader *shader, AttributeRequestSet *attributes);
766         bool has_spatial_varying() { return true; }
767
768         ustring attribute;
769 };
770
771 class CameraNode : public ShaderNode {
772 public:
773         SHADER_NODE_CLASS(CameraNode)
774         bool has_spatial_varying() { return true; }
775         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
776 };
777
778 class FresnelNode : public ShaderNode {
779 public:
780         SHADER_NODE_CLASS(FresnelNode)
781         bool has_spatial_varying() { return true; }
782         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
783
784         float3 normal;
785         float IOR;
786 };
787
788 class LayerWeightNode : public ShaderNode {
789 public:
790         SHADER_NODE_CLASS(LayerWeightNode)
791         bool has_spatial_varying() { return true; }
792         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
793
794         float3 normal;
795         float blend;
796 };
797
798 class WireframeNode : public ShaderNode {
799 public:
800         SHADER_NODE_CLASS(WireframeNode)
801         bool has_spatial_varying() { return true; }
802         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
803
804         float size;
805         bool use_pixel_size;
806 };
807
808 class WavelengthNode : public ShaderNode {
809 public:
810         SHADER_NODE_CLASS(WavelengthNode)
811         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
812
813         float wavelength;
814 };
815
816 class BlackbodyNode : public ShaderNode {
817 public:
818         SHADER_NODE_CLASS(BlackbodyNode)
819         void constant_fold(const ConstantFolder& folder);
820         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
821
822         float temperature;
823 };
824
825 class MathNode : public ShaderNode {
826 public:
827         SHADER_NODE_CLASS(MathNode)
828         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
829         void constant_fold(const ConstantFolder& folder);
830
831         float value1;
832         float value2;
833         NodeMath type;
834         bool use_clamp;
835 };
836
837 class NormalNode : public ShaderNode {
838 public:
839         SHADER_NODE_CLASS(NormalNode)
840         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
841
842         float3 direction;
843         float3 normal;
844 };
845
846 class VectorMathNode : public ShaderNode {
847 public:
848         SHADER_NODE_CLASS(VectorMathNode)
849         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
850         void constant_fold(const ConstantFolder& folder);
851
852         float3 vector1;
853         float3 vector2;
854         NodeVectorMath type;
855 };
856
857 class VectorTransformNode : public ShaderNode {
858 public:
859         SHADER_NODE_CLASS(VectorTransformNode)
860
861         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
862
863         NodeVectorTransformType type;
864         NodeVectorTransformConvertSpace convert_from;
865         NodeVectorTransformConvertSpace convert_to;
866         float3 vector;
867 };
868
869 class BumpNode : public ShaderNode {
870 public:
871         SHADER_NODE_CLASS(BumpNode)
872         void constant_fold(const ConstantFolder& folder);
873         bool has_spatial_varying() { return true; }
874         virtual int get_feature() {
875                 return NODE_FEATURE_BUMP;
876         }
877
878         bool invert;
879         bool use_object_space;
880         float height;
881         float sample_center;
882         float sample_x;
883         float sample_y;
884         float3 normal;
885         float strength;
886         float distance;
887 };
888
889 class CurvesNode : public ShaderNode {
890 public:
891         explicit CurvesNode(const NodeType *node_type);
892         SHADER_NODE_BASE_CLASS(CurvesNode)
893
894         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
895
896         array<float3> curves;
897         float min_x, max_x, fac;
898         float3 value;
899
900 protected:
901         void constant_fold(const ConstantFolder& folder, ShaderInput *value_in);
902         void compile(SVMCompiler& compiler, int type, ShaderInput *value_in, ShaderOutput *value_out);
903         void compile(OSLCompiler& compiler, const char *name);
904 };
905
906 class RGBCurvesNode : public CurvesNode {
907 public:
908         SHADER_NODE_CLASS(RGBCurvesNode)
909         void constant_fold(const ConstantFolder& folder);
910 };
911
912 class VectorCurvesNode : public CurvesNode {
913 public:
914         SHADER_NODE_CLASS(VectorCurvesNode)
915         void constant_fold(const ConstantFolder& folder);
916 };
917
918 class RGBRampNode : public ShaderNode {
919 public:
920         SHADER_NODE_CLASS(RGBRampNode)
921         void constant_fold(const ConstantFolder& folder);
922         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
923
924         array<float3> ramp;
925         array<float> ramp_alpha;
926         float fac;
927         bool interpolate;
928 };
929
930 class SetNormalNode : public ShaderNode {
931 public:
932         SHADER_NODE_CLASS(SetNormalNode)
933         float3 direction;
934 };
935
936 class OSLNode : public ShaderNode {
937 public:
938         static OSLNode *create(size_t num_inputs, const OSLNode *from = NULL);
939         ~OSLNode();
940
941         ShaderNode *clone() const;
942
943         char* input_default_value();
944         void add_input(ustring name, SocketType::Type type);
945         void add_output(ustring name, SocketType::Type type);
946
947         SHADER_NODE_NO_CLONE_CLASS(OSLNode)
948
949         /* ideally we could beter detect this, but we can't query this now */
950         bool has_spatial_varying() { return true; }
951         virtual bool equals(const ShaderNode& /*other*/) { return false; }
952
953         string filepath;
954         string bytecode_hash;
955 };
956
957 class NormalMapNode : public ShaderNode {
958 public:
959         SHADER_NODE_CLASS(NormalMapNode)
960         void attributes(Shader *shader, AttributeRequestSet *attributes);
961         bool has_spatial_varying() { return true; }
962         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
963
964         NodeNormalMapSpace space;
965         ustring attribute;
966         float strength;
967         float3 color;
968         float3 normal_osl;
969 };
970
971 class TangentNode : public ShaderNode {
972 public:
973         SHADER_NODE_CLASS(TangentNode)
974         void attributes(Shader *shader, AttributeRequestSet *attributes);
975         bool has_spatial_varying() { return true; }
976         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
977
978         NodeTangentDirectionType direction_type;
979         NodeTangentAxis axis;
980         ustring attribute;
981         float3 normal_osl;
982 };
983
984 CCL_NAMESPACE_END
985
986 #endif /* __NODES_H__ */
987