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