Fix Cycles debug build assert on some platforms, tighten checks to avoid this in...
[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 #include "node.h"
22
23 #include "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, 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         bool constant_fold(ShaderGraph *graph, ShaderOutput *socket, ShaderInput *optimized);
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         bool constant_fold(ShaderGraph *graph, ShaderOutput *socket, ShaderInput *optimized);
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         void attributes(Shader *shader, AttributeRequestSet *attributes);
354 };
355
356 class DiffuseBsdfNode : public BsdfNode {
357 public:
358         SHADER_NODE_CLASS(DiffuseBsdfNode)
359
360         float roughness;
361 };
362
363 class TranslucentBsdfNode : public BsdfNode {
364 public:
365         SHADER_NODE_CLASS(TranslucentBsdfNode)
366 };
367
368 class TransparentBsdfNode : public BsdfNode {
369 public:
370         SHADER_NODE_CLASS(TransparentBsdfNode)
371
372         bool has_surface_transparent() { return true; }
373 };
374
375 class VelvetBsdfNode : public BsdfNode {
376 public:
377         SHADER_NODE_CLASS(VelvetBsdfNode)
378
379         float sigma;
380 };
381
382 class GlossyBsdfNode : public BsdfNode {
383 public:
384         SHADER_NODE_CLASS(GlossyBsdfNode)
385
386         void simplify_settings(Scene *scene);
387         bool has_integrator_dependency();
388
389         float roughness;
390         ClosureType distribution, distribution_orig;
391 };
392
393 class GlassBsdfNode : public BsdfNode {
394 public:
395         SHADER_NODE_CLASS(GlassBsdfNode)
396
397         void simplify_settings(Scene *scene);
398         bool has_integrator_dependency();
399
400         float roughness, IOR;
401         ClosureType distribution, distribution_orig;
402 };
403
404 class RefractionBsdfNode : public BsdfNode {
405 public:
406         SHADER_NODE_CLASS(RefractionBsdfNode)
407
408         void simplify_settings(Scene *scene);
409         bool has_integrator_dependency();
410
411         float roughness, IOR;
412         ClosureType distribution, distribution_orig;
413 };
414
415 class ToonBsdfNode : public BsdfNode {
416 public:
417         SHADER_NODE_CLASS(ToonBsdfNode)
418
419         float smooth, size;
420         ClosureType component;
421 };
422
423 class SubsurfaceScatteringNode : public BsdfNode {
424 public:
425         SHADER_NODE_CLASS(SubsurfaceScatteringNode)
426         bool has_surface_bssrdf() { return true; }
427         bool has_bssrdf_bump();
428
429         float scale;
430         float3 radius;
431         float sharpness;
432         float texture_blur;
433         ClosureType falloff;
434 };
435
436 class EmissionNode : public ShaderNode {
437 public:
438         SHADER_NODE_CLASS(EmissionNode)
439         bool constant_fold(ShaderGraph *graph, ShaderOutput *socket, ShaderInput *optimized);
440         virtual ClosureType get_closure_type() { return CLOSURE_EMISSION_ID; }
441
442         bool has_surface_emission() { return true; }
443
444         float3 color;
445         float strength;
446         float surface_mix_weight;
447 };
448
449 class BackgroundNode : public ShaderNode {
450 public:
451         SHADER_NODE_CLASS(BackgroundNode)
452         bool constant_fold(ShaderGraph *graph, ShaderOutput *socket, ShaderInput *optimized);
453         virtual ClosureType get_closure_type() { return CLOSURE_BACKGROUND_ID; }
454
455         float3 color;
456         float strength;
457         float surface_mix_weight;
458 };
459
460 class HoldoutNode : public ShaderNode {
461 public:
462         SHADER_NODE_CLASS(HoldoutNode)
463         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
464         virtual ClosureType get_closure_type() { return CLOSURE_HOLDOUT_ID; }
465
466         float surface_mix_weight;
467         float volume_mix_weight;
468 };
469
470 class AmbientOcclusionNode : public ShaderNode {
471 public:
472         SHADER_NODE_CLASS(AmbientOcclusionNode)
473
474         bool has_spatial_varying() { return true; }
475         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
476         virtual ClosureType get_closure_type() { return CLOSURE_AMBIENT_OCCLUSION_ID; }
477
478         float3 normal_osl;
479         float3 color;
480         float surface_mix_weight;
481 };
482
483 class VolumeNode : public ShaderNode {
484 public:
485         VolumeNode(const NodeType *node_type);
486         SHADER_NODE_BASE_CLASS(VolumeNode)
487
488         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
489         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
490         virtual int get_feature() {
491                 return ShaderNode::get_feature() | NODE_FEATURE_VOLUME;
492         }
493         virtual ClosureType get_closure_type() { return closure; }
494
495         float3 color;
496         float density;
497         float volume_mix_weight;
498         ClosureType closure;
499
500         virtual bool equals(const ShaderNode& /*other*/)
501         {
502                 /* TODO(sergey): With some care Volume nodes can be de-duplicated. */
503                 return false;
504         }
505 };
506
507 class AbsorptionVolumeNode : public VolumeNode {
508 public:
509         SHADER_NODE_CLASS(AbsorptionVolumeNode)
510 };
511
512 class ScatterVolumeNode : public VolumeNode {
513 public:
514         SHADER_NODE_CLASS(ScatterVolumeNode)
515
516         float anisotropy;
517 };
518
519 class HairBsdfNode : public BsdfNode {
520 public:
521         SHADER_NODE_CLASS(HairBsdfNode)
522
523         ClosureType component;
524         float offset;
525         float roughness_u;
526         float roughness_v;
527         float3 tangent;
528 };
529
530 class GeometryNode : public ShaderNode {
531 public:
532         SHADER_NODE_CLASS(GeometryNode)
533         void attributes(Shader *shader, AttributeRequestSet *attributes);
534         bool has_spatial_varying() { return true; }
535
536         float3 normal_osl;
537 };
538
539 class TextureCoordinateNode : public ShaderNode {
540 public:
541         SHADER_NODE_CLASS(TextureCoordinateNode)
542         void attributes(Shader *shader, AttributeRequestSet *attributes);
543         bool has_spatial_varying() { return true; }
544         bool has_object_dependency() { return use_transform; }
545
546         float3 normal_osl;
547         bool from_dupli;
548         bool use_transform;
549         Transform ob_tfm;
550 };
551
552 class UVMapNode : public ShaderNode {
553 public:
554         SHADER_NODE_CLASS(UVMapNode)
555         void attributes(Shader *shader, AttributeRequestSet *attributes);
556         bool has_spatial_varying() { return true; }
557         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
558
559         ustring attribute;
560         bool from_dupli;
561 };
562
563 class LightPathNode : public ShaderNode {
564 public:
565         SHADER_NODE_CLASS(LightPathNode)
566         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
567 };
568
569 class LightFalloffNode : public ShaderNode {
570 public:
571         SHADER_NODE_CLASS(LightFalloffNode)
572         bool has_spatial_varying() { return true; }
573         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
574
575         float strength;
576         float smooth;
577 };
578
579 class ObjectInfoNode : public ShaderNode {
580 public:
581         SHADER_NODE_CLASS(ObjectInfoNode)
582         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
583 };
584
585 class ParticleInfoNode : public ShaderNode {
586 public:
587         SHADER_NODE_CLASS(ParticleInfoNode)
588         void attributes(Shader *shader, AttributeRequestSet *attributes);
589         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
590 };
591
592 class HairInfoNode : public ShaderNode {
593 public:
594         SHADER_NODE_CLASS(HairInfoNode)
595
596         void attributes(Shader *shader, AttributeRequestSet *attributes);
597         bool has_spatial_varying() { return true; }
598         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
599         virtual int get_feature() {
600                 return ShaderNode::get_feature() | NODE_FEATURE_HAIR;
601         }
602 };
603
604 class ValueNode : public ShaderNode {
605 public:
606         SHADER_NODE_CLASS(ValueNode)
607
608         bool constant_fold(ShaderGraph *graph, ShaderOutput *socket, ShaderInput *optimized);
609
610         float value;
611 };
612
613 class ColorNode : public ShaderNode {
614 public:
615         SHADER_NODE_CLASS(ColorNode)
616
617         bool constant_fold(ShaderGraph *graph, ShaderOutput *socket, ShaderInput *optimized);
618
619         float3 value;
620 };
621
622 class AddClosureNode : public ShaderNode {
623 public:
624         SHADER_NODE_CLASS(AddClosureNode)
625 };
626
627 class MixClosureNode : public ShaderNode {
628 public:
629         SHADER_NODE_CLASS(MixClosureNode)
630         bool constant_fold(ShaderGraph *graph, ShaderOutput *socket, ShaderInput *optimized);
631
632         float fac;
633 };
634
635 class MixClosureWeightNode : public ShaderNode {
636 public:
637         SHADER_NODE_CLASS(MixClosureWeightNode);
638
639         float weight;
640         float fac;
641 };
642
643 class InvertNode : public ShaderNode {
644 public:
645         SHADER_NODE_CLASS(InvertNode)
646
647         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
648
649         float fac;
650         float3 color;
651 };
652
653 class MixNode : public ShaderNode {
654 public:
655         SHADER_NODE_CLASS(MixNode)
656         bool constant_fold(ShaderGraph *graph, ShaderOutput *socket, ShaderInput *optimized);
657
658         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
659
660         NodeMix type;
661         bool use_clamp;
662         float3 color1;
663         float3 color2;
664         float fac;
665 };
666
667 class CombineRGBNode : public ShaderNode {
668 public:
669         SHADER_NODE_CLASS(CombineRGBNode)
670         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
671
672         float r, g, b;
673 };
674
675 class CombineHSVNode : public ShaderNode {
676 public:
677         SHADER_NODE_CLASS(CombineHSVNode)
678         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
679
680         float h, s, v;
681 };
682
683 class CombineXYZNode : public ShaderNode {
684 public:
685         SHADER_NODE_CLASS(CombineXYZNode)
686         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
687
688         float x, y, z;
689 };
690
691 class GammaNode : public ShaderNode {
692 public:
693         SHADER_NODE_CLASS(GammaNode)
694         bool constant_fold(ShaderGraph *graph, ShaderOutput *socket, ShaderInput *optimized);
695         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
696
697         float3 color;
698         float gamma;
699 };
700
701 class BrightContrastNode : public ShaderNode {
702 public:
703         SHADER_NODE_CLASS(BrightContrastNode)
704         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
705
706         float3 color;
707         float bright;
708         float contrast;
709 };
710
711 class SeparateRGBNode : public ShaderNode {
712 public:
713         SHADER_NODE_CLASS(SeparateRGBNode)
714         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
715
716         float3 color;
717 };
718
719 class SeparateHSVNode : public ShaderNode {
720 public:
721         SHADER_NODE_CLASS(SeparateHSVNode)
722         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
723
724         float3 color;
725 };
726
727 class SeparateXYZNode : public ShaderNode {
728 public:
729         SHADER_NODE_CLASS(SeparateXYZNode)
730         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
731
732         float3 vector;
733 };
734
735 class HSVNode : public ShaderNode {
736 public:
737         SHADER_NODE_CLASS(HSVNode)
738
739         float hue;
740         float saturation;
741         float value;
742         float fac;
743         float3 color;
744 };
745
746 class AttributeNode : public ShaderNode {
747 public:
748         SHADER_NODE_CLASS(AttributeNode)
749         void attributes(Shader *shader, AttributeRequestSet *attributes);
750         bool has_spatial_varying() { return true; }
751
752         ustring attribute;
753 };
754
755 class CameraNode : public ShaderNode {
756 public:
757         SHADER_NODE_CLASS(CameraNode)
758         bool has_spatial_varying() { return true; }
759 };
760
761 class FresnelNode : public ShaderNode {
762 public:
763         SHADER_NODE_CLASS(FresnelNode)
764         bool has_spatial_varying() { return true; }
765         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
766
767         float3 normal;
768         float IOR;
769 };
770
771 class LayerWeightNode : public ShaderNode {
772 public:
773         SHADER_NODE_CLASS(LayerWeightNode)
774         bool has_spatial_varying() { return true; }
775         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
776
777         float3 normal;
778         float blend;
779 };
780
781 class WireframeNode : public ShaderNode {
782 public:
783         SHADER_NODE_CLASS(WireframeNode)
784         bool has_spatial_varying() { return true; }
785         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
786
787         float size;
788         bool use_pixel_size;
789 };
790
791 class WavelengthNode : public ShaderNode {
792 public:
793         SHADER_NODE_CLASS(WavelengthNode)
794         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
795
796         float wavelength;
797 };
798
799 class BlackbodyNode : public ShaderNode {
800 public:
801         SHADER_NODE_CLASS(BlackbodyNode)
802         bool constant_fold(ShaderGraph *graph, ShaderOutput *socket, ShaderInput *optimized);
803         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
804
805         float temperature;
806 };
807
808 class MathNode : public ShaderNode {
809 public:
810         SHADER_NODE_CLASS(MathNode)
811         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
812         bool constant_fold(ShaderGraph *graph, ShaderOutput *socket, ShaderInput *optimized);
813
814         float value1;
815         float value2;
816         NodeMath type;
817         bool use_clamp;
818 };
819
820 class NormalNode : public ShaderNode {
821 public:
822         SHADER_NODE_CLASS(NormalNode)
823         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
824
825         float3 direction;
826         float3 normal;
827 };
828
829 class VectorMathNode : public ShaderNode {
830 public:
831         SHADER_NODE_CLASS(VectorMathNode)
832         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
833         bool constant_fold(ShaderGraph *graph, ShaderOutput *socket, ShaderInput *optimized);
834
835         float3 vector1;
836         float3 vector2;
837         NodeVectorMath type;
838 };
839
840 class VectorTransformNode : public ShaderNode {
841 public:
842         SHADER_NODE_CLASS(VectorTransformNode)
843
844         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
845
846         NodeVectorTransformType type;
847         NodeVectorTransformConvertSpace convert_from;
848         NodeVectorTransformConvertSpace convert_to;
849         float3 vector;
850 };
851
852 class BumpNode : public ShaderNode {
853 public:
854         SHADER_NODE_CLASS(BumpNode)
855         bool constant_fold(ShaderGraph *graph, ShaderOutput *socket, ShaderInput *optimized);
856         bool has_spatial_varying() { return true; }
857         virtual int get_feature() {
858                 return NODE_FEATURE_BUMP;
859         }
860
861         bool invert;
862         float height;
863         float sample_center;
864         float sample_x;
865         float sample_y;
866         float3 normal;
867         float strength;
868         float distance;
869 };
870
871 class RGBCurvesNode : public ShaderNode {
872 public:
873         SHADER_NODE_CLASS(RGBCurvesNode)
874
875         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
876
877         array<float3> curves;
878         float min_x, max_x, fac;
879         float3 color;
880 };
881
882 class VectorCurvesNode : public ShaderNode {
883 public:
884         SHADER_NODE_CLASS(VectorCurvesNode)
885
886         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
887
888         array<float3> curves;
889         float min_x, max_x, fac;
890         float3 vector;
891 };
892
893 class RGBRampNode : public ShaderNode {
894 public:
895         SHADER_NODE_CLASS(RGBRampNode)
896         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
897
898         array<float3> ramp;
899         array<float> ramp_alpha;
900         float fac;
901         bool interpolate;
902 };
903
904 class SetNormalNode : public ShaderNode {
905 public:
906         SHADER_NODE_CLASS(SetNormalNode)
907         float3 direction;
908 };
909
910 class OSLNode : public ShaderNode {
911 public:
912         static OSLNode *create(size_t num_inputs);
913         ~OSLNode();
914
915         char* input_default_value();
916         void add_input(ustring name, SocketType::Type type);
917         void add_output(ustring name, SocketType::Type type);
918
919         SHADER_NODE_BASE_CLASS(OSLNode)
920
921         /* ideally we could beter detect this, but we can't query this now */
922         bool has_spatial_varying() { return true; }
923         virtual bool equals(const ShaderNode& /*other*/) { return false; }
924
925         string filepath;
926         string bytecode_hash;
927
928 private:
929         OSLNode();
930 };
931
932 class NormalMapNode : public ShaderNode {
933 public:
934         SHADER_NODE_CLASS(NormalMapNode)
935         void attributes(Shader *shader, AttributeRequestSet *attributes);
936         bool has_spatial_varying() { return true; }
937         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
938
939         NodeNormalMapSpace space;
940         ustring attribute;
941         float strength;
942         float3 color;
943         float3 normal_osl;
944 };
945
946 class TangentNode : public ShaderNode {
947 public:
948         SHADER_NODE_CLASS(TangentNode)
949         void attributes(Shader *shader, AttributeRequestSet *attributes);
950         bool has_spatial_varying() { return true; }
951         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
952
953         NodeTangentDirectionType direction_type;
954         NodeTangentAxis axis;
955         ustring attribute;
956         float3 normal_osl;
957 };
958
959 CCL_NAMESPACE_END
960
961 #endif /* __NODES_H__ */
962