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