1fa4b67c6b97512c8cd9dffcd5087784932c045c
[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
22 #include "util_string.h"
23
24 CCL_NAMESPACE_BEGIN
25
26 class ImageManager;
27 class Scene;
28 class Shader;
29
30 /* Texture Mapping */
31
32 class TextureMapping {
33 public:
34         TextureMapping();
35         Transform compute_transform();
36         bool skip();
37         void compile(SVMCompiler& compiler, int offset_in, int offset_out);
38         void compile(OSLCompiler &compiler);
39
40         float3 translation;
41         float3 rotation;
42         float3 scale;
43
44         float3 min, max;
45         bool use_minmax;
46
47         enum Type { POINT = 0, TEXTURE = 1, VECTOR = 2, NORMAL = 3 };
48         Type type;
49
50         enum Mapping { NONE = 0, X = 1, Y = 2, Z = 3 };
51         Mapping x_mapping, y_mapping, z_mapping;
52
53         enum Projection { FLAT, CUBE, TUBE, SPHERE };
54         Projection projection;
55 };
56
57 /* Nodes */
58
59 /* Any node which uses image manager's slot should be a subclass of this one. */
60 class ImageSlotNode : public ShaderNode {
61 public:
62         ImageSlotNode(const char *name_) : ShaderNode(name_) {
63                 special_type = SHADER_SPECIAL_TYPE_IMAGE_SLOT;
64         }
65         int slot;
66 };
67
68 class TextureNode : public ShaderNode {
69 public:
70         TextureNode(const char *name_) : ShaderNode(name_) {}
71         TextureMapping tex_mapping;
72 };
73
74 class ImageSlotTextureNode : public ImageSlotNode {
75 public:
76         ImageSlotTextureNode(const char *name_) : ImageSlotNode(name_) {}
77         TextureMapping tex_mapping;
78 };
79
80 class ImageTextureNode : public ImageSlotTextureNode {
81 public:
82         SHADER_NODE_NO_CLONE_CLASS(ImageTextureNode)
83         ~ImageTextureNode();
84         ShaderNode *clone() const;
85         void attributes(Shader *shader, AttributeRequestSet *attributes);
86
87         ImageManager *image_manager;
88         int is_float;
89         bool is_linear;
90         bool use_alpha;
91         string filename;
92         void *builtin_data;
93         ustring color_space;
94         ustring projection;
95         InterpolationType interpolation;
96         ExtensionType extension;
97         float projection_blend;
98         bool animated;
99
100         static ShaderEnum color_space_enum;
101         static ShaderEnum projection_enum;
102 };
103
104 class EnvironmentTextureNode : public ImageSlotTextureNode {
105 public:
106         SHADER_NODE_NO_CLONE_CLASS(EnvironmentTextureNode)
107         ~EnvironmentTextureNode();
108         ShaderNode *clone() const;
109         void attributes(Shader *shader, AttributeRequestSet *attributes);
110         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
111
112         ImageManager *image_manager;
113         int is_float;
114         bool is_linear;
115         bool use_alpha;
116         string filename;
117         void *builtin_data;
118         ustring color_space;
119         ustring projection;
120         InterpolationType interpolation;
121         bool animated;
122
123         static ShaderEnum color_space_enum;
124         static ShaderEnum projection_enum;
125 };
126
127 class SkyTextureNode : public TextureNode {
128 public:
129         SHADER_NODE_CLASS(SkyTextureNode)
130
131         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
132
133         float3 sun_direction;
134         float turbidity;
135         float ground_albedo;
136         
137         ustring type;
138         static ShaderEnum type_enum;
139 };
140
141 class OutputNode : public ShaderNode {
142 public:
143         SHADER_NODE_CLASS(OutputNode)
144 };
145
146 class GradientTextureNode : public TextureNode {
147 public:
148         SHADER_NODE_CLASS(GradientTextureNode)
149
150         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
151
152         ustring type;
153         static ShaderEnum type_enum;
154 };
155
156 class NoiseTextureNode : public TextureNode {
157 public:
158         SHADER_NODE_CLASS(NoiseTextureNode)
159 };
160
161 class VoronoiTextureNode : public TextureNode {
162 public:
163         SHADER_NODE_CLASS(VoronoiTextureNode)
164
165         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
166
167         ustring coloring;
168
169         static ShaderEnum coloring_enum;
170 };
171
172 class MusgraveTextureNode : public TextureNode {
173 public:
174         SHADER_NODE_CLASS(MusgraveTextureNode)
175
176         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
177
178         ustring type;
179
180         static ShaderEnum type_enum;
181 };
182
183 class WaveTextureNode : public TextureNode {
184 public:
185         SHADER_NODE_CLASS(WaveTextureNode)
186
187         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
188
189         ustring type;
190         static ShaderEnum type_enum;
191 };
192
193 class MagicTextureNode : public TextureNode {
194 public:
195         SHADER_NODE_CLASS(MagicTextureNode)
196
197         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
198
199         int depth;
200 };
201
202 class CheckerTextureNode : public TextureNode {
203 public:
204         SHADER_NODE_CLASS(CheckerTextureNode)
205
206         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
207 };
208
209 class BrickTextureNode : public TextureNode {
210 public:
211         SHADER_NODE_CLASS(BrickTextureNode)
212         
213         float offset, squash;
214         int offset_frequency, squash_frequency;
215
216         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
217 };
218
219 class PointDensityTextureNode : public ShaderNode {
220 public:
221         SHADER_NODE_NO_CLONE_CLASS(PointDensityTextureNode)
222
223         ~PointDensityTextureNode();
224         ShaderNode *clone() const;
225         void attributes(Shader *shader, AttributeRequestSet *attributes);
226
227         bool has_spatial_varying() { return true; }
228         bool has_object_dependency() { return true; }
229
230         ImageManager *image_manager;
231         int slot;
232         string filename;
233         ustring space;
234         void *builtin_data;
235         InterpolationType interpolation;
236
237         Transform tfm;
238
239         static ShaderEnum space_enum;
240 };
241
242 class MappingNode : public ShaderNode {
243 public:
244         SHADER_NODE_CLASS(MappingNode)
245         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
246
247         TextureMapping tex_mapping;
248 };
249
250 class ConvertNode : public ShaderNode {
251 public:
252         ConvertNode(ShaderSocketType from, ShaderSocketType to, bool autoconvert = false);
253         SHADER_NODE_BASE_CLASS(ConvertNode)
254
255         ShaderSocketType from, to;
256 };
257
258 class ProxyNode : public ShaderNode {
259 public:
260         ProxyNode(ShaderSocketType type);
261         SHADER_NODE_BASE_CLASS(ProxyNode)
262
263         ShaderSocketType type;
264 };
265
266 class BsdfNode : public ShaderNode {
267 public:
268         BsdfNode(bool scattering = false);
269         SHADER_NODE_BASE_CLASS(BsdfNode);
270
271         bool has_spatial_varying() { return true; }
272         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2, ShaderInput *param3 = NULL, ShaderInput *param4 = NULL);
273
274         ClosureType closure;
275         bool scattering;
276 };
277
278 class AnisotropicBsdfNode : public BsdfNode {
279 public:
280         SHADER_NODE_CLASS(AnisotropicBsdfNode)
281
282         ustring distribution;
283         static ShaderEnum distribution_enum;
284
285         void attributes(Shader *shader, AttributeRequestSet *attributes);
286 };
287
288 class DiffuseBsdfNode : public BsdfNode {
289 public:
290         SHADER_NODE_CLASS(DiffuseBsdfNode)
291 };
292
293 class TranslucentBsdfNode : public BsdfNode {
294 public:
295         SHADER_NODE_CLASS(TranslucentBsdfNode)
296 };
297
298 class TransparentBsdfNode : public BsdfNode {
299 public:
300         SHADER_NODE_CLASS(TransparentBsdfNode)
301
302         bool has_surface_transparent() { return true; }
303 };
304
305 class VelvetBsdfNode : public BsdfNode {
306 public:
307         SHADER_NODE_CLASS(VelvetBsdfNode)
308 };
309
310 class GlossyBsdfNode : public BsdfNode {
311 public:
312         SHADER_NODE_CLASS(GlossyBsdfNode)
313
314         void simplify_settings(Scene *scene);
315         bool has_integrator_dependency();
316
317         ustring distribution, distribution_orig;
318         static ShaderEnum distribution_enum;
319 };
320
321 class GlassBsdfNode : public BsdfNode {
322 public:
323         SHADER_NODE_CLASS(GlassBsdfNode)
324
325         void simplify_settings(Scene *scene);
326         bool has_integrator_dependency();
327
328         ustring distribution, distribution_orig;
329         static ShaderEnum distribution_enum;
330 };
331
332 class RefractionBsdfNode : public BsdfNode {
333 public:
334         SHADER_NODE_CLASS(RefractionBsdfNode)
335
336         void simplify_settings(Scene *scene);
337         bool has_integrator_dependency();
338
339         ustring distribution, distribution_orig;
340         static ShaderEnum distribution_enum;
341 };
342
343 class ToonBsdfNode : public BsdfNode {
344 public:
345         SHADER_NODE_CLASS(ToonBsdfNode)
346
347         ustring component;
348         static ShaderEnum component_enum;
349 };
350
351 class SubsurfaceScatteringNode : public BsdfNode {
352 public:
353         SHADER_NODE_CLASS(SubsurfaceScatteringNode)
354         bool has_surface_bssrdf() { return true; }
355         bool has_bssrdf_bump();
356         bool has_spatial_varying() { return true; }
357
358         static ShaderEnum falloff_enum;
359 };
360
361 class EmissionNode : public ShaderNode {
362 public:
363         SHADER_NODE_CLASS(EmissionNode)
364
365         bool has_surface_emission() { return true; }
366         bool has_spatial_varying() { return true; }
367 };
368
369 class BackgroundNode : public ShaderNode {
370 public:
371         SHADER_NODE_CLASS(BackgroundNode)
372 };
373
374 class HoldoutNode : public ShaderNode {
375 public:
376         SHADER_NODE_CLASS(HoldoutNode)
377         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
378 };
379
380 class AmbientOcclusionNode : public ShaderNode {
381 public:
382         SHADER_NODE_CLASS(AmbientOcclusionNode)
383
384         bool has_spatial_varying() { return true; }
385         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
386 };
387
388 class VolumeNode : public ShaderNode {
389 public:
390         SHADER_NODE_CLASS(VolumeNode)
391
392         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
393         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
394
395         ClosureType closure;
396 };
397
398 class AbsorptionVolumeNode : public VolumeNode {
399 public:
400         SHADER_NODE_CLASS(AbsorptionVolumeNode)
401 };
402
403 class ScatterVolumeNode : public VolumeNode {
404 public:
405         SHADER_NODE_CLASS(ScatterVolumeNode)
406 };
407
408 class HairBsdfNode : public BsdfNode {
409 public:
410         SHADER_NODE_CLASS(HairBsdfNode)
411
412         ustring component;
413         static ShaderEnum component_enum;
414
415 };
416
417 class GeometryNode : public ShaderNode {
418 public:
419         SHADER_NODE_CLASS(GeometryNode)
420         void attributes(Shader *shader, AttributeRequestSet *attributes);
421         bool has_spatial_varying() { return true; }
422 };
423
424 class TextureCoordinateNode : public ShaderNode {
425 public:
426         SHADER_NODE_CLASS(TextureCoordinateNode)
427         void attributes(Shader *shader, AttributeRequestSet *attributes);
428         bool has_spatial_varying() { return true; }
429         bool has_object_dependency() { return use_transform; }
430
431         bool from_dupli;
432         bool use_transform;
433         Transform ob_tfm;
434 };
435
436 class UVMapNode : public ShaderNode {
437 public:
438         SHADER_NODE_CLASS(UVMapNode)
439         void attributes(Shader *shader, AttributeRequestSet *attributes);
440         bool has_spatial_varying() { return true; }
441         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
442
443         ustring attribute;
444         bool from_dupli;
445 };
446
447 class LightPathNode : public ShaderNode {
448 public:
449         SHADER_NODE_CLASS(LightPathNode)
450         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
451 };
452
453 class LightFalloffNode : public ShaderNode {
454 public:
455         SHADER_NODE_CLASS(LightFalloffNode)
456         bool has_spatial_varying() { return true; }
457 };
458
459 class ObjectInfoNode : public ShaderNode {
460 public:
461         SHADER_NODE_CLASS(ObjectInfoNode)
462         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
463 };
464
465 class ParticleInfoNode : public ShaderNode {
466 public:
467         SHADER_NODE_CLASS(ParticleInfoNode)
468         void attributes(Shader *shader, AttributeRequestSet *attributes);
469         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
470 };
471
472 class HairInfoNode : public ShaderNode {
473 public:
474         SHADER_NODE_CLASS(HairInfoNode)
475
476         void attributes(Shader *shader, AttributeRequestSet *attributes);
477         bool has_spatial_varying() { return true; }
478         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
479         virtual int get_feature() {
480                 return ShaderNode::get_feature() | NODE_FEATURE_HAIR;
481         }
482 };
483
484 class ValueNode : public ShaderNode {
485 public:
486         SHADER_NODE_CLASS(ValueNode)
487
488         float value;
489 };
490
491 class ColorNode : public ShaderNode {
492 public:
493         SHADER_NODE_CLASS(ColorNode)
494
495         float3 value;
496 };
497
498 class AddClosureNode : public ShaderNode {
499 public:
500         SHADER_NODE_CLASS(AddClosureNode)
501 };
502
503 class MixClosureNode : public ShaderNode {
504 public:
505         SHADER_NODE_CLASS(MixClosureNode)
506 };
507
508 class MixClosureWeightNode : public ShaderNode {
509 public:
510         SHADER_NODE_CLASS(MixClosureWeightNode);
511 };
512
513 class InvertNode : public ShaderNode {
514 public:
515         SHADER_NODE_CLASS(InvertNode)
516
517         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
518 };
519
520 class MixNode : public ShaderNode {
521 public:
522         SHADER_NODE_CLASS(MixNode)
523
524         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
525
526         bool use_clamp;
527
528         ustring type;
529         static ShaderEnum type_enum;
530 };
531
532 class CombineRGBNode : public ShaderNode {
533 public:
534         SHADER_NODE_CLASS(CombineRGBNode)
535
536         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
537 };
538
539 class CombineHSVNode : public ShaderNode {
540 public:
541         SHADER_NODE_CLASS(CombineHSVNode)
542
543         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
544 };
545
546 class CombineXYZNode : public ShaderNode {
547 public:
548         SHADER_NODE_CLASS(CombineXYZNode)
549
550         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
551 };
552
553 class GammaNode : public ShaderNode {
554 public:
555         SHADER_NODE_CLASS(GammaNode)
556         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
557 };
558
559 class BrightContrastNode : public ShaderNode {
560 public:
561         SHADER_NODE_CLASS(BrightContrastNode)
562         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
563 };
564
565 class SeparateRGBNode : public ShaderNode {
566 public:
567         SHADER_NODE_CLASS(SeparateRGBNode)
568
569         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
570 };
571
572 class SeparateHSVNode : public ShaderNode {
573 public:
574         SHADER_NODE_CLASS(SeparateHSVNode)
575
576         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
577 };
578
579 class SeparateXYZNode : public ShaderNode {
580 public:
581         SHADER_NODE_CLASS(SeparateXYZNode)
582
583         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
584 };
585
586 class HSVNode : public ShaderNode {
587 public:
588         SHADER_NODE_CLASS(HSVNode)
589 };
590
591 class AttributeNode : public ShaderNode {
592 public:
593         SHADER_NODE_CLASS(AttributeNode)
594         void attributes(Shader *shader, AttributeRequestSet *attributes);
595         bool has_spatial_varying() { return true; }
596
597         ustring attribute;
598 };
599
600 class CameraNode : public ShaderNode {
601 public:
602         SHADER_NODE_CLASS(CameraNode)
603         bool has_spatial_varying() { return true; }
604 };
605
606 class FresnelNode : public ShaderNode {
607 public:
608         SHADER_NODE_CLASS(FresnelNode)
609         bool has_spatial_varying() { return true; }
610         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
611 };
612
613 class LayerWeightNode : public ShaderNode {
614 public:
615         SHADER_NODE_CLASS(LayerWeightNode)
616         bool has_spatial_varying() { return true; }
617         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
618 };
619
620 class WireframeNode : public ShaderNode {
621 public:
622         SHADER_NODE_CLASS(WireframeNode)
623         bool has_spatial_varying() { return true; }
624         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
625         
626         bool use_pixel_size;
627 };
628
629 class WavelengthNode : public ShaderNode {
630 public:
631         SHADER_NODE_CLASS(WavelengthNode)
632
633         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
634 };
635
636 class BlackbodyNode : public ShaderNode {
637 public:
638         SHADER_NODE_CLASS(BlackbodyNode)
639         bool constant_fold(ShaderOutput *socket, float3 *optimized_value);
640
641         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
642 };
643
644 class MathNode : public ShaderNode {
645 public:
646         SHADER_NODE_CLASS(MathNode)
647         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
648         bool constant_fold(ShaderOutput *socket, float3 *optimized_value);
649
650         bool use_clamp;
651
652         ustring type;
653         static ShaderEnum type_enum;
654 };
655
656 class NormalNode : public ShaderNode {
657 public:
658         SHADER_NODE_CLASS(NormalNode)
659         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
660
661         float3 direction;
662 };
663
664 class VectorMathNode : public ShaderNode {
665 public:
666         SHADER_NODE_CLASS(VectorMathNode)
667         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
668         bool constant_fold(ShaderOutput *socket, float3 *optimized_value);
669
670         ustring type;
671         static ShaderEnum type_enum;
672 };
673
674 class VectorTransformNode : public ShaderNode {
675 public:
676         SHADER_NODE_CLASS(VectorTransformNode)
677
678         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
679
680         ustring type;
681         ustring convert_from;
682         ustring convert_to;
683         
684         static ShaderEnum type_enum;
685         static ShaderEnum convert_space_enum;
686 };
687
688 class BumpNode : public ShaderNode {
689 public:
690         SHADER_NODE_CLASS(BumpNode)
691         bool has_spatial_varying() { return true; }
692         virtual int get_feature() {
693                 return NODE_FEATURE_BUMP;
694         }
695
696         bool invert;
697 };
698
699 class RGBCurvesNode : public ShaderNode {
700 public:
701         SHADER_NODE_CLASS(RGBCurvesNode)
702
703         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
704
705         float4 curves[RAMP_TABLE_SIZE];
706         float min_x, max_x;
707 };
708
709 class VectorCurvesNode : public ShaderNode {
710 public:
711         SHADER_NODE_CLASS(VectorCurvesNode)
712
713         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
714
715         float4 curves[RAMP_TABLE_SIZE];
716 };
717
718 class RGBRampNode : public ShaderNode {
719 public:
720         SHADER_NODE_CLASS(RGBRampNode)
721         float4 ramp[RAMP_TABLE_SIZE];
722         bool interpolate;
723         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
724 };
725
726 class SetNormalNode : public ShaderNode {
727 public:
728         SHADER_NODE_CLASS(SetNormalNode)
729 };
730
731 class OSLScriptNode : public ShaderNode {
732 public:
733         SHADER_NODE_CLASS(OSLScriptNode)
734
735         /* ideally we could beter detect this, but we can't query this now */
736         bool has_spatial_varying() { return true; }
737
738         string filepath;
739         string bytecode_hash;
740         
741         /* ShaderInput/ShaderOutput only stores a shallow string copy (const char *)!
742          * The actual socket names have to be stored externally to avoid memory errors. */
743         vector<ustring> input_names;
744         vector<ustring> output_names;
745 };
746
747 class NormalMapNode : public ShaderNode {
748 public:
749         SHADER_NODE_CLASS(NormalMapNode)
750         void attributes(Shader *shader, AttributeRequestSet *attributes);
751         bool has_spatial_varying() { return true; }
752         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
753
754         ustring space;
755         static ShaderEnum space_enum;
756
757         ustring attribute;
758 };
759
760 class TangentNode : public ShaderNode {
761 public:
762         SHADER_NODE_CLASS(TangentNode)
763         void attributes(Shader *shader, AttributeRequestSet *attributes);
764         bool has_spatial_varying() { return true; }
765         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
766
767         ustring direction_type;
768         static ShaderEnum direction_type_enum;
769
770         ustring axis;
771         static ShaderEnum axis_enum;
772
773         ustring attribute;
774 };
775
776 CCL_NAMESPACE_END
777
778 #endif /* __NODES_H__ */
779