a00b48ca5bcf4afe14c2f8bd92cd90894005da63
[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         float3 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         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
256
257         ~PointDensityTextureNode();
258         ShaderNode *clone() const;
259         void attributes(Shader *shader, AttributeRequestSet *attributes);
260
261         bool has_spatial_varying() { return true; }
262         bool has_object_dependency() { return true; }
263
264         ustring filename;
265         NodeTexVoxelSpace space;
266         InterpolationType interpolation;
267         Transform tfm;
268         float3 vector;
269
270         ImageManager *image_manager;
271         int slot;
272         void *builtin_data;
273
274         virtual bool equals(const ShaderNode& other) {
275                 const PointDensityTextureNode& point_dendity_node = (const PointDensityTextureNode&)other;
276                 return ShaderNode::equals(other) &&
277                        builtin_data == point_dendity_node.builtin_data;
278         }
279 };
280
281 class MappingNode : public ShaderNode {
282 public:
283         SHADER_NODE_CLASS(MappingNode)
284         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
285
286         float3 vector;
287         TextureMapping tex_mapping;
288 };
289
290 class RGBToBWNode : public ShaderNode {
291 public:
292         SHADER_NODE_CLASS(RGBToBWNode)
293         void constant_fold(const ConstantFolder& folder);
294
295         float3 color;
296 };
297
298 class ConvertNode : public ShaderNode {
299 public:
300         ConvertNode(SocketType::Type from, SocketType::Type to, bool autoconvert = false);
301         SHADER_NODE_BASE_CLASS(ConvertNode)
302
303         void constant_fold(const ConstantFolder& folder);
304
305         SocketType::Type from, to;
306
307         union {
308                 float value_float;
309                 int value_int;
310                 float3 value_color;
311                 float3 value_vector;
312                 float3 value_point;
313                 float3 value_normal;
314         };
315         ustring value_string;
316
317 private:
318         static const int MAX_TYPE = 12;
319         static bool register_types();
320         static Node* create(const NodeType *type);
321         static const NodeType *node_types[MAX_TYPE][MAX_TYPE];
322         static bool initialized;
323 };
324
325 class BsdfBaseNode : public ShaderNode {
326 public:
327         BsdfBaseNode(const NodeType *node_type);
328
329         bool has_spatial_varying() { return true; }
330         virtual ClosureType get_closure_type() { return closure; }
331         virtual bool has_bump();
332
333         virtual bool equals(const ShaderNode& /*other*/)
334         {
335                 /* TODO(sergey): With some care BSDF nodes can be de-duplicated. */
336                 return false;
337         }
338
339         ClosureType closure;
340 };
341
342 class BsdfNode : public BsdfBaseNode {
343 public:
344         explicit BsdfNode(const NodeType *node_type);
345         SHADER_NODE_BASE_CLASS(BsdfNode)
346
347         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2, ShaderInput *param3 = NULL, ShaderInput *param4 = NULL);
348
349         float3 color;
350         float3 normal;
351         float surface_mix_weight;
352 };
353
354 class AnisotropicBsdfNode : public BsdfNode {
355 public:
356         SHADER_NODE_CLASS(AnisotropicBsdfNode)
357
358         float3 tangent;
359         float roughness, anisotropy, rotation;
360         ClosureType distribution;
361
362         ClosureType get_closure_type() { return distribution; }
363         void attributes(Shader *shader, AttributeRequestSet *attributes);
364 };
365
366 class DiffuseBsdfNode : public BsdfNode {
367 public:
368         SHADER_NODE_CLASS(DiffuseBsdfNode)
369
370         float roughness;
371 };
372
373 /* Disney principled BRDF */
374 class PrincipledBsdfNode : public BsdfBaseNode {
375 public:
376         SHADER_NODE_CLASS(PrincipledBsdfNode)
377
378         bool has_surface_bssrdf();
379         bool has_bssrdf_bump();
380         void compile(SVMCompiler& compiler, ShaderInput *metallic, ShaderInput *subsurface, ShaderInput *subsurface_radius,
381                 ShaderInput *specular, ShaderInput *roughness, ShaderInput *specular_tint, ShaderInput *anisotropic,
382                 ShaderInput *sheen, ShaderInput *sheen_tint, ShaderInput *clearcoat, ShaderInput *clearcoat_roughness,
383                 ShaderInput *ior, ShaderInput *transmission, ShaderInput *anisotropic_rotation, ShaderInput *transmission_roughness);
384
385         float3 base_color;
386         float3 subsurface_color, subsurface_radius;
387         float metallic, subsurface, specular, roughness, specular_tint, anisotropic,
388                 sheen, sheen_tint, clearcoat, clearcoat_roughness, ior, transmission,
389                 anisotropic_rotation, transmission_roughness;
390         float3 normal, clearcoat_normal, tangent;
391         float surface_mix_weight;
392         ClosureType distribution, distribution_orig;
393
394         bool has_integrator_dependency();
395         void attributes(Shader *shader, AttributeRequestSet *attributes);
396 };
397
398 class TranslucentBsdfNode : public BsdfNode {
399 public:
400         SHADER_NODE_CLASS(TranslucentBsdfNode)
401 };
402
403 class TransparentBsdfNode : public BsdfNode {
404 public:
405         SHADER_NODE_CLASS(TransparentBsdfNode)
406
407         bool has_surface_transparent() { return true; }
408 };
409
410 class VelvetBsdfNode : public BsdfNode {
411 public:
412         SHADER_NODE_CLASS(VelvetBsdfNode)
413
414         float sigma;
415 };
416
417 class GlossyBsdfNode : public BsdfNode {
418 public:
419         SHADER_NODE_CLASS(GlossyBsdfNode)
420
421         void simplify_settings(Scene *scene);
422         bool has_integrator_dependency();
423         ClosureType get_closure_type() { return distribution; }
424
425         float roughness, roughness_orig;
426         ClosureType distribution, distribution_orig;
427 };
428
429 class GlassBsdfNode : public BsdfNode {
430 public:
431         SHADER_NODE_CLASS(GlassBsdfNode)
432
433         void simplify_settings(Scene *scene);
434         bool has_integrator_dependency();
435         ClosureType get_closure_type() { return distribution; }
436
437         float roughness, roughness_orig, IOR;
438         ClosureType distribution, distribution_orig;
439 };
440
441 class RefractionBsdfNode : public BsdfNode {
442 public:
443         SHADER_NODE_CLASS(RefractionBsdfNode)
444
445         void simplify_settings(Scene *scene);
446         bool has_integrator_dependency();
447         ClosureType get_closure_type() { return distribution; }
448
449         float roughness, roughness_orig, IOR;
450         ClosureType distribution, distribution_orig;
451 };
452
453 class ToonBsdfNode : public BsdfNode {
454 public:
455         SHADER_NODE_CLASS(ToonBsdfNode)
456
457         float smooth, size;
458         ClosureType component;
459 };
460
461 class SubsurfaceScatteringNode : public BsdfNode {
462 public:
463         SHADER_NODE_CLASS(SubsurfaceScatteringNode)
464         bool has_surface_bssrdf() { return true; }
465         bool has_bssrdf_bump();
466         ClosureType get_closure_type() { return falloff; }
467
468         float scale;
469         float3 radius;
470         float sharpness;
471         float texture_blur;
472         ClosureType falloff;
473 };
474
475 class EmissionNode : public ShaderNode {
476 public:
477         SHADER_NODE_CLASS(EmissionNode)
478         void constant_fold(const ConstantFolder& folder);
479
480         bool has_surface_emission() { return true; }
481         bool has_volume_support() { return true; }
482
483         float3 color;
484         float strength;
485         float surface_mix_weight;
486 };
487
488 class BackgroundNode : public ShaderNode {
489 public:
490         SHADER_NODE_CLASS(BackgroundNode)
491         void constant_fold(const ConstantFolder& folder);
492
493         float3 color;
494         float strength;
495         float surface_mix_weight;
496 };
497
498 class HoldoutNode : public ShaderNode {
499 public:
500         SHADER_NODE_CLASS(HoldoutNode)
501         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
502         virtual ClosureType get_closure_type() { return CLOSURE_HOLDOUT_ID; }
503
504         float surface_mix_weight;
505         float volume_mix_weight;
506 };
507
508 class AmbientOcclusionNode : public ShaderNode {
509 public:
510         SHADER_NODE_CLASS(AmbientOcclusionNode)
511
512         bool has_spatial_varying() { return true; }
513         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
514         virtual ClosureType get_closure_type() { return CLOSURE_AMBIENT_OCCLUSION_ID; }
515
516         float3 normal_osl;
517         float3 color;
518         float surface_mix_weight;
519 };
520
521 class VolumeNode : public ShaderNode {
522 public:
523         VolumeNode(const NodeType *node_type);
524         SHADER_NODE_BASE_CLASS(VolumeNode)
525
526         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
527         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
528         virtual int get_feature() {
529                 return ShaderNode::get_feature() | NODE_FEATURE_VOLUME;
530         }
531         virtual ClosureType get_closure_type() { return closure; }
532         virtual bool has_volume_support() { return true; }
533
534         float3 color;
535         float density;
536         float volume_mix_weight;
537         ClosureType closure;
538
539         virtual bool equals(const ShaderNode& /*other*/)
540         {
541                 /* TODO(sergey): With some care Volume nodes can be de-duplicated. */
542                 return false;
543         }
544 };
545
546 class AbsorptionVolumeNode : public VolumeNode {
547 public:
548         SHADER_NODE_CLASS(AbsorptionVolumeNode)
549 };
550
551 class ScatterVolumeNode : public VolumeNode {
552 public:
553         SHADER_NODE_CLASS(ScatterVolumeNode)
554
555         float anisotropy;
556 };
557
558 class HairBsdfNode : public BsdfNode {
559 public:
560         SHADER_NODE_CLASS(HairBsdfNode)
561         ClosureType get_closure_type() { return component; }
562
563         ClosureType component;
564         float offset;
565         float roughness_u;
566         float roughness_v;
567         float3 tangent;
568 };
569
570 class GeometryNode : public ShaderNode {
571 public:
572         SHADER_NODE_CLASS(GeometryNode)
573         void attributes(Shader *shader, AttributeRequestSet *attributes);
574         bool has_spatial_varying() { return true; }
575
576         float3 normal_osl;
577 };
578
579 class TextureCoordinateNode : public ShaderNode {
580 public:
581         SHADER_NODE_CLASS(TextureCoordinateNode)
582         void attributes(Shader *shader, AttributeRequestSet *attributes);
583         bool has_spatial_varying() { return true; }
584         bool has_object_dependency() { return use_transform; }
585
586         float3 normal_osl;
587         bool from_dupli;
588         bool use_transform;
589         Transform ob_tfm;
590 };
591
592 class UVMapNode : public ShaderNode {
593 public:
594         SHADER_NODE_CLASS(UVMapNode)
595         void attributes(Shader *shader, AttributeRequestSet *attributes);
596         bool has_spatial_varying() { return true; }
597         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
598
599         ustring attribute;
600         bool from_dupli;
601 };
602
603 class LightPathNode : public ShaderNode {
604 public:
605         SHADER_NODE_CLASS(LightPathNode)
606         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
607 };
608
609 class LightFalloffNode : public ShaderNode {
610 public:
611         SHADER_NODE_CLASS(LightFalloffNode)
612         bool has_spatial_varying() { return true; }
613         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
614
615         float strength;
616         float smooth;
617 };
618
619 class ObjectInfoNode : public ShaderNode {
620 public:
621         SHADER_NODE_CLASS(ObjectInfoNode)
622         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
623 };
624
625 class ParticleInfoNode : public ShaderNode {
626 public:
627         SHADER_NODE_CLASS(ParticleInfoNode)
628         void attributes(Shader *shader, AttributeRequestSet *attributes);
629         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
630 };
631
632 class HairInfoNode : public ShaderNode {
633 public:
634         SHADER_NODE_CLASS(HairInfoNode)
635
636         void attributes(Shader *shader, AttributeRequestSet *attributes);
637         bool has_spatial_varying() { return true; }
638         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
639         virtual int get_feature() {
640                 return ShaderNode::get_feature() | NODE_FEATURE_HAIR;
641         }
642 };
643
644 class ValueNode : public ShaderNode {
645 public:
646         SHADER_NODE_CLASS(ValueNode)
647
648         void constant_fold(const ConstantFolder& folder);
649
650         float value;
651 };
652
653 class ColorNode : public ShaderNode {
654 public:
655         SHADER_NODE_CLASS(ColorNode)
656
657         void constant_fold(const ConstantFolder& folder);
658
659         float3 value;
660 };
661
662 class AddClosureNode : public ShaderNode {
663 public:
664         SHADER_NODE_CLASS(AddClosureNode)
665         void constant_fold(const ConstantFolder& folder);
666 };
667
668 class MixClosureNode : public ShaderNode {
669 public:
670         SHADER_NODE_CLASS(MixClosureNode)
671         void constant_fold(const ConstantFolder& folder);
672
673         float fac;
674 };
675
676 class MixClosureWeightNode : public ShaderNode {
677 public:
678         SHADER_NODE_CLASS(MixClosureWeightNode)
679
680         float weight;
681         float fac;
682 };
683
684 class InvertNode : public ShaderNode {
685 public:
686         SHADER_NODE_CLASS(InvertNode)
687         void constant_fold(const ConstantFolder& folder);
688         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
689
690         float fac;
691         float3 color;
692 };
693
694 class MixNode : public ShaderNode {
695 public:
696         SHADER_NODE_CLASS(MixNode)
697         void constant_fold(const ConstantFolder& folder);
698
699         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
700
701         NodeMix type;
702         bool use_clamp;
703         float3 color1;
704         float3 color2;
705         float fac;
706 };
707
708 class CombineRGBNode : public ShaderNode {
709 public:
710         SHADER_NODE_CLASS(CombineRGBNode)
711         void constant_fold(const ConstantFolder& folder);
712         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
713
714         float r, g, b;
715 };
716
717 class CombineHSVNode : public ShaderNode {
718 public:
719         SHADER_NODE_CLASS(CombineHSVNode)
720         void constant_fold(const ConstantFolder& folder);
721         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
722
723         float h, s, v;
724 };
725
726 class CombineXYZNode : public ShaderNode {
727 public:
728         SHADER_NODE_CLASS(CombineXYZNode)
729         void constant_fold(const ConstantFolder& folder);
730         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
731
732         float x, y, z;
733 };
734
735 class GammaNode : public ShaderNode {
736 public:
737         SHADER_NODE_CLASS(GammaNode)
738         void constant_fold(const ConstantFolder& folder);
739         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
740
741         float3 color;
742         float gamma;
743 };
744
745 class BrightContrastNode : public ShaderNode {
746 public:
747         SHADER_NODE_CLASS(BrightContrastNode)
748         void constant_fold(const ConstantFolder& folder);
749         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
750
751         float3 color;
752         float bright;
753         float contrast;
754 };
755
756 class SeparateRGBNode : public ShaderNode {
757 public:
758         SHADER_NODE_CLASS(SeparateRGBNode)
759         void constant_fold(const ConstantFolder& folder);
760         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
761
762         float3 color;
763 };
764
765 class SeparateHSVNode : public ShaderNode {
766 public:
767         SHADER_NODE_CLASS(SeparateHSVNode)
768         void constant_fold(const ConstantFolder& folder);
769         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
770
771         float3 color;
772 };
773
774 class SeparateXYZNode : public ShaderNode {
775 public:
776         SHADER_NODE_CLASS(SeparateXYZNode)
777         void constant_fold(const ConstantFolder& folder);
778         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
779
780         float3 vector;
781 };
782
783 class HSVNode : public ShaderNode {
784 public:
785         SHADER_NODE_CLASS(HSVNode)
786
787         float hue;
788         float saturation;
789         float value;
790         float fac;
791         float3 color;
792 };
793
794 class AttributeNode : public ShaderNode {
795 public:
796         SHADER_NODE_CLASS(AttributeNode)
797         void attributes(Shader *shader, AttributeRequestSet *attributes);
798         bool has_spatial_varying() { return true; }
799
800         ustring attribute;
801 };
802
803 class CameraNode : public ShaderNode {
804 public:
805         SHADER_NODE_CLASS(CameraNode)
806         bool has_spatial_varying() { return true; }
807         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
808 };
809
810 class FresnelNode : public ShaderNode {
811 public:
812         SHADER_NODE_CLASS(FresnelNode)
813         bool has_spatial_varying() { return true; }
814         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
815
816         float3 normal;
817         float IOR;
818 };
819
820 class LayerWeightNode : public ShaderNode {
821 public:
822         SHADER_NODE_CLASS(LayerWeightNode)
823         bool has_spatial_varying() { return true; }
824         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
825
826         float3 normal;
827         float blend;
828 };
829
830 class WireframeNode : public ShaderNode {
831 public:
832         SHADER_NODE_CLASS(WireframeNode)
833         bool has_spatial_varying() { return true; }
834         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
835
836         float size;
837         bool use_pixel_size;
838 };
839
840 class WavelengthNode : public ShaderNode {
841 public:
842         SHADER_NODE_CLASS(WavelengthNode)
843         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
844
845         float wavelength;
846 };
847
848 class BlackbodyNode : public ShaderNode {
849 public:
850         SHADER_NODE_CLASS(BlackbodyNode)
851         void constant_fold(const ConstantFolder& folder);
852         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
853
854         float temperature;
855 };
856
857 class MathNode : public ShaderNode {
858 public:
859         SHADER_NODE_CLASS(MathNode)
860         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
861         void constant_fold(const ConstantFolder& folder);
862
863         float value1;
864         float value2;
865         NodeMath type;
866         bool use_clamp;
867 };
868
869 class NormalNode : public ShaderNode {
870 public:
871         SHADER_NODE_CLASS(NormalNode)
872         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
873
874         float3 direction;
875         float3 normal;
876 };
877
878 class VectorMathNode : public ShaderNode {
879 public:
880         SHADER_NODE_CLASS(VectorMathNode)
881         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
882         void constant_fold(const ConstantFolder& folder);
883
884         float3 vector1;
885         float3 vector2;
886         NodeVectorMath type;
887 };
888
889 class VectorTransformNode : public ShaderNode {
890 public:
891         SHADER_NODE_CLASS(VectorTransformNode)
892
893         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
894
895         NodeVectorTransformType type;
896         NodeVectorTransformConvertSpace convert_from;
897         NodeVectorTransformConvertSpace convert_to;
898         float3 vector;
899 };
900
901 class BumpNode : public ShaderNode {
902 public:
903         SHADER_NODE_CLASS(BumpNode)
904         void constant_fold(const ConstantFolder& folder);
905         bool has_spatial_varying() { return true; }
906         virtual int get_feature() {
907                 return NODE_FEATURE_BUMP;
908         }
909
910         bool invert;
911         bool use_object_space;
912         float height;
913         float sample_center;
914         float sample_x;
915         float sample_y;
916         float3 normal;
917         float strength;
918         float distance;
919 };
920
921 class CurvesNode : public ShaderNode {
922 public:
923         explicit CurvesNode(const NodeType *node_type);
924         SHADER_NODE_BASE_CLASS(CurvesNode)
925
926         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
927
928         array<float3> curves;
929         float min_x, max_x, fac;
930         float3 value;
931
932 protected:
933         void constant_fold(const ConstantFolder& folder, ShaderInput *value_in);
934         void compile(SVMCompiler& compiler, int type, ShaderInput *value_in, ShaderOutput *value_out);
935         void compile(OSLCompiler& compiler, const char *name);
936 };
937
938 class RGBCurvesNode : public CurvesNode {
939 public:
940         SHADER_NODE_CLASS(RGBCurvesNode)
941         void constant_fold(const ConstantFolder& folder);
942 };
943
944 class VectorCurvesNode : public CurvesNode {
945 public:
946         SHADER_NODE_CLASS(VectorCurvesNode)
947         void constant_fold(const ConstantFolder& folder);
948 };
949
950 class RGBRampNode : public ShaderNode {
951 public:
952         SHADER_NODE_CLASS(RGBRampNode)
953         void constant_fold(const ConstantFolder& folder);
954         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
955
956         array<float3> ramp;
957         array<float> ramp_alpha;
958         float fac;
959         bool interpolate;
960 };
961
962 class SetNormalNode : public ShaderNode {
963 public:
964         SHADER_NODE_CLASS(SetNormalNode)
965         float3 direction;
966 };
967
968 class OSLNode : public ShaderNode {
969 public:
970         static OSLNode *create(size_t num_inputs, const OSLNode *from = NULL);
971         ~OSLNode();
972
973         ShaderNode *clone() const;
974
975         char* input_default_value();
976         void add_input(ustring name, SocketType::Type type);
977         void add_output(ustring name, SocketType::Type type);
978
979         SHADER_NODE_NO_CLONE_CLASS(OSLNode)
980
981         /* ideally we could beter detect this, but we can't query this now */
982         bool has_spatial_varying() { return true; }
983         bool has_volume_support() { return true; }
984
985         virtual bool equals(const ShaderNode& /*other*/) { return false; }
986
987         string filepath;
988         string bytecode_hash;
989 };
990
991 class NormalMapNode : public ShaderNode {
992 public:
993         SHADER_NODE_CLASS(NormalMapNode)
994         void attributes(Shader *shader, AttributeRequestSet *attributes);
995         bool has_spatial_varying() { return true; }
996         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
997
998         NodeNormalMapSpace space;
999         ustring attribute;
1000         float strength;
1001         float3 color;
1002         float3 normal_osl;
1003 };
1004
1005 class TangentNode : public ShaderNode {
1006 public:
1007         SHADER_NODE_CLASS(TangentNode)
1008         void attributes(Shader *shader, AttributeRequestSet *attributes);
1009         bool has_spatial_varying() { return true; }
1010         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
1011
1012         NodeTangentDirectionType direction_type;
1013         NodeTangentAxis axis;
1014         ustring attribute;
1015         float3 normal_osl;
1016 };
1017
1018 class BevelNode : public ShaderNode {
1019 public:
1020         SHADER_NODE_CLASS(BevelNode)
1021         bool has_spatial_varying() { return true; }
1022         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
1023         virtual bool has_raytrace() { return true; }
1024
1025         float radius;
1026         float3 normal;
1027         int samples;
1028 };
1029
1030 class DisplacementNode : public ShaderNode {
1031 public:
1032         SHADER_NODE_CLASS(DisplacementNode)
1033         virtual int get_feature() {
1034                 return NODE_FEATURE_BUMP;
1035         }
1036
1037         NodeNormalMapSpace space;
1038         float height;
1039         float midlevel;
1040         float scale;
1041         float3 normal;
1042 };
1043
1044 class VectorDisplacementNode : public ShaderNode {
1045 public:
1046         SHADER_NODE_CLASS(VectorDisplacementNode)
1047         void attributes(Shader *shader, AttributeRequestSet *attributes);
1048         virtual int get_feature() {
1049                 return NODE_FEATURE_BUMP;
1050         }
1051
1052         NodeNormalMapSpace space;
1053         ustring attribute;
1054         float3 vector;
1055         float midlevel;
1056         float scale;
1057 };
1058
1059 CCL_NAMESPACE_END
1060
1061 #endif /* __NODES_H__ */
1062