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