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