Cycles: add dedicated UV Map node, easier to find and has convenient auto complete.
[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 class TextureNode : public ShaderNode {
59 public:
60         TextureNode(const char *name_) : ShaderNode(name_) {}
61         TextureMapping tex_mapping;
62 };
63
64 class ImageTextureNode : public TextureNode {
65 public:
66         SHADER_NODE_NO_CLONE_CLASS(ImageTextureNode)
67         ~ImageTextureNode();
68         ShaderNode *clone() const;
69         void attributes(Shader *shader, AttributeRequestSet *attributes);
70
71         ImageManager *image_manager;
72         int slot;
73         int is_float;
74         bool is_linear;
75         string filename;
76         void *builtin_data;
77         ustring color_space;
78         ustring projection;
79         InterpolationType interpolation;
80         float projection_blend;
81         bool animated;
82
83         static ShaderEnum color_space_enum;
84         static ShaderEnum projection_enum;
85 };
86
87 class EnvironmentTextureNode : public TextureNode {
88 public:
89         SHADER_NODE_NO_CLONE_CLASS(EnvironmentTextureNode)
90         ~EnvironmentTextureNode();
91         ShaderNode *clone() const;
92         void attributes(Shader *shader, AttributeRequestSet *attributes);
93
94         ImageManager *image_manager;
95         int slot;
96         int is_float;
97         bool is_linear;
98         string filename;
99         void *builtin_data;
100         ustring color_space;
101         ustring projection;
102         bool animated;
103
104         static ShaderEnum color_space_enum;
105         static ShaderEnum projection_enum;
106 };
107
108 class SkyTextureNode : public TextureNode {
109 public:
110         SHADER_NODE_CLASS(SkyTextureNode)
111
112         float3 sun_direction;
113         float turbidity;
114         float ground_albedo;
115         
116         ustring type;
117         static ShaderEnum type_enum;
118 };
119
120 class OutputNode : public ShaderNode {
121 public:
122         SHADER_NODE_CLASS(OutputNode)
123 };
124
125 class GradientTextureNode : public TextureNode {
126 public:
127         SHADER_NODE_CLASS(GradientTextureNode)
128
129         ustring type;
130         static ShaderEnum type_enum;
131 };
132
133 class NoiseTextureNode : public TextureNode {
134 public:
135         SHADER_NODE_CLASS(NoiseTextureNode)
136 };
137
138 class VoronoiTextureNode : public TextureNode {
139 public:
140         SHADER_NODE_CLASS(VoronoiTextureNode)
141
142         ustring coloring;
143
144         static ShaderEnum coloring_enum;
145 };
146
147 class MusgraveTextureNode : public TextureNode {
148 public:
149         SHADER_NODE_CLASS(MusgraveTextureNode)
150
151         ustring type;
152
153         static ShaderEnum type_enum;
154 };
155
156 class WaveTextureNode : public TextureNode {
157 public:
158         SHADER_NODE_CLASS(WaveTextureNode)
159
160         ustring type;
161         static ShaderEnum type_enum;
162 };
163
164 class MagicTextureNode : public TextureNode {
165 public:
166         SHADER_NODE_CLASS(MagicTextureNode)
167
168         int depth;
169 };
170
171 class CheckerTextureNode : public TextureNode {
172 public:
173         SHADER_NODE_CLASS(CheckerTextureNode)
174 };
175
176 class BrickTextureNode : public TextureNode {
177 public:
178         SHADER_NODE_CLASS(BrickTextureNode)
179         
180         float offset, squash;
181         int offset_frequency, squash_frequency;
182 };
183
184 class MappingNode : public ShaderNode {
185 public:
186         SHADER_NODE_CLASS(MappingNode)
187
188         TextureMapping tex_mapping;
189 };
190
191 class ConvertNode : public ShaderNode {
192 public:
193         ConvertNode(ShaderSocketType from, ShaderSocketType to, bool autoconvert = false);
194         SHADER_NODE_BASE_CLASS(ConvertNode)
195
196         ShaderSocketType from, to;
197 };
198
199 class ProxyNode : public ShaderNode {
200 public:
201         ProxyNode(ShaderSocketType type);
202         SHADER_NODE_BASE_CLASS(ProxyNode)
203
204         ShaderSocketType type;
205 };
206
207 class BsdfNode : public ShaderNode {
208 public:
209         BsdfNode(bool scattering = false);
210         SHADER_NODE_BASE_CLASS(BsdfNode);
211
212         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2, ShaderInput *param3 = NULL, ShaderInput *param4 = NULL);
213
214         ClosureType closure;
215         bool scattering;
216 };
217
218 class WardBsdfNode : public BsdfNode {
219 public:
220         SHADER_NODE_CLASS(WardBsdfNode)
221         void attributes(Shader *shader, AttributeRequestSet *attributes);
222 };
223
224 class DiffuseBsdfNode : public BsdfNode {
225 public:
226         SHADER_NODE_CLASS(DiffuseBsdfNode)
227 };
228
229 class TranslucentBsdfNode : public BsdfNode {
230 public:
231         SHADER_NODE_CLASS(TranslucentBsdfNode)
232 };
233
234 class TransparentBsdfNode : public BsdfNode {
235 public:
236         SHADER_NODE_CLASS(TransparentBsdfNode)
237
238         bool has_surface_transparent() { return true; }
239 };
240
241 class VelvetBsdfNode : public BsdfNode {
242 public:
243         SHADER_NODE_CLASS(VelvetBsdfNode)
244 };
245
246 class GlossyBsdfNode : public BsdfNode {
247 public:
248         SHADER_NODE_CLASS(GlossyBsdfNode)
249
250         ustring distribution;
251         static ShaderEnum distribution_enum;
252 };
253
254 class GlassBsdfNode : public BsdfNode {
255 public:
256         SHADER_NODE_CLASS(GlassBsdfNode)
257
258         ustring distribution;
259         static ShaderEnum distribution_enum;
260 };
261
262 class RefractionBsdfNode : public BsdfNode {
263 public:
264         SHADER_NODE_CLASS(RefractionBsdfNode)
265
266         ustring distribution;
267         static ShaderEnum distribution_enum;
268 };
269
270 class ToonBsdfNode : public BsdfNode {
271 public:
272         SHADER_NODE_CLASS(ToonBsdfNode)
273
274         ustring component;
275         static ShaderEnum component_enum;
276 };
277
278 class SubsurfaceScatteringNode : public BsdfNode {
279 public:
280         SHADER_NODE_CLASS(SubsurfaceScatteringNode)
281         bool has_surface_bssrdf() { return true; }
282         bool has_bssrdf_bump();
283
284         static ShaderEnum falloff_enum;
285 };
286
287 class EmissionNode : public ShaderNode {
288 public:
289         SHADER_NODE_CLASS(EmissionNode)
290
291         bool has_surface_emission() { return true; }
292
293         bool total_power;
294 };
295
296 class BackgroundNode : public ShaderNode {
297 public:
298         SHADER_NODE_CLASS(BackgroundNode)
299 };
300
301 class HoldoutNode : public ShaderNode {
302 public:
303         SHADER_NODE_CLASS(HoldoutNode)
304 };
305
306 class AmbientOcclusionNode : public ShaderNode {
307 public:
308         SHADER_NODE_CLASS(AmbientOcclusionNode)
309 };
310
311 class VolumeNode : public ShaderNode {
312 public:
313         SHADER_NODE_CLASS(VolumeNode)
314
315         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
316
317         ClosureType closure;
318 };
319
320 class AbsorptionVolumeNode : public VolumeNode {
321 public:
322         SHADER_NODE_CLASS(AbsorptionVolumeNode)
323 };
324
325 class ScatterVolumeNode : public VolumeNode {
326 public:
327         SHADER_NODE_CLASS(ScatterVolumeNode)
328 };
329
330 class HairBsdfNode : public BsdfNode {
331 public:
332         SHADER_NODE_CLASS(HairBsdfNode)
333
334         ustring component;
335         static ShaderEnum component_enum;
336
337 };
338
339 class GeometryNode : public ShaderNode {
340 public:
341         SHADER_NODE_CLASS(GeometryNode)
342         void attributes(Shader *shader, AttributeRequestSet *attributes);
343 };
344
345 class TextureCoordinateNode : public ShaderNode {
346 public:
347         SHADER_NODE_CLASS(TextureCoordinateNode)
348         void attributes(Shader *shader, AttributeRequestSet *attributes);
349         
350         bool from_dupli;
351 };
352
353 class UVMapNode : public ShaderNode {
354 public:
355         SHADER_NODE_CLASS(UVMapNode)
356         void attributes(Shader *shader, AttributeRequestSet *attributes);
357
358         ustring attribute;
359         bool from_dupli;
360 };
361
362 class LightPathNode : public ShaderNode {
363 public:
364         SHADER_NODE_CLASS(LightPathNode)
365 };
366
367 class LightFalloffNode : public ShaderNode {
368 public:
369         SHADER_NODE_CLASS(LightFalloffNode)
370 };
371
372 class ObjectInfoNode : public ShaderNode {
373 public:
374         SHADER_NODE_CLASS(ObjectInfoNode)
375 };
376
377 class ParticleInfoNode : public ShaderNode {
378 public:
379         SHADER_NODE_CLASS(ParticleInfoNode)
380         void attributes(Shader *shader, AttributeRequestSet *attributes);
381 };
382
383 class HairInfoNode : public ShaderNode {
384 public:
385         SHADER_NODE_CLASS(HairInfoNode)
386
387         void attributes(Shader *shader, AttributeRequestSet *attributes);
388 };
389
390 class ValueNode : public ShaderNode {
391 public:
392         SHADER_NODE_CLASS(ValueNode)
393
394         float value;
395 };
396
397 class ColorNode : public ShaderNode {
398 public:
399         SHADER_NODE_CLASS(ColorNode)
400
401         float3 value;
402 };
403
404 class AddClosureNode : public ShaderNode {
405 public:
406         SHADER_NODE_CLASS(AddClosureNode)
407 };
408
409 class MixClosureNode : public ShaderNode {
410 public:
411         SHADER_NODE_CLASS(MixClosureNode)
412 };
413
414 class MixClosureWeightNode : public ShaderNode {
415 public:
416         SHADER_NODE_CLASS(MixClosureWeightNode);
417 };
418
419 class InvertNode : public ShaderNode {
420 public:
421         SHADER_NODE_CLASS(InvertNode)
422 };
423
424 class MixNode : public ShaderNode {
425 public:
426         SHADER_NODE_CLASS(MixNode)
427
428         bool use_clamp;
429
430         ustring type;
431         static ShaderEnum type_enum;
432 };
433
434 class CombineRGBNode : public ShaderNode {
435 public:
436         SHADER_NODE_CLASS(CombineRGBNode)
437 };
438
439 class CombineHSVNode : public ShaderNode {
440 public:
441         SHADER_NODE_CLASS(CombineHSVNode)
442 };
443
444 class GammaNode : public ShaderNode {
445 public:
446         SHADER_NODE_CLASS(GammaNode)
447 };
448
449 class BrightContrastNode : public ShaderNode {
450 public:
451         SHADER_NODE_CLASS(BrightContrastNode)
452 };
453
454 class SeparateRGBNode : public ShaderNode {
455 public:
456         SHADER_NODE_CLASS(SeparateRGBNode)
457 };
458
459 class SeparateHSVNode : public ShaderNode {
460 public:
461         SHADER_NODE_CLASS(SeparateHSVNode)
462 };
463
464 class HSVNode : public ShaderNode {
465 public:
466         SHADER_NODE_CLASS(HSVNode)
467 };
468
469 class AttributeNode : public ShaderNode {
470 public:
471         SHADER_NODE_CLASS(AttributeNode)
472         void attributes(Shader *shader, AttributeRequestSet *attributes);
473
474         ustring attribute;
475 };
476
477 class CameraNode : public ShaderNode {
478 public:
479         SHADER_NODE_CLASS(CameraNode)
480 };
481
482 class FresnelNode : public ShaderNode {
483 public:
484         SHADER_NODE_CLASS(FresnelNode)
485 };
486
487 class LayerWeightNode : public ShaderNode {
488 public:
489         SHADER_NODE_CLASS(LayerWeightNode)
490 };
491
492 class WireframeNode : public ShaderNode {
493 public:
494         SHADER_NODE_CLASS(WireframeNode)
495         
496         bool use_pixel_size;
497 };
498
499 class WavelengthNode : public ShaderNode {
500 public:
501         SHADER_NODE_CLASS(WavelengthNode)
502 };
503
504 class BlackbodyNode : public ShaderNode {
505 public:
506         SHADER_NODE_CLASS(BlackbodyNode)
507         
508         bool has_converter_blackbody() { return true; }
509 };
510
511 class MathNode : public ShaderNode {
512 public:
513         SHADER_NODE_CLASS(MathNode)
514
515         bool use_clamp;
516
517         ustring type;
518         static ShaderEnum type_enum;
519 };
520
521 class NormalNode : public ShaderNode {
522 public:
523         SHADER_NODE_CLASS(NormalNode)
524
525         float3 direction;
526 };
527
528 class VectorMathNode : public ShaderNode {
529 public:
530         SHADER_NODE_CLASS(VectorMathNode)
531
532         ustring type;
533         static ShaderEnum type_enum;
534 };
535
536 class VectorTransformNode : public ShaderNode {
537 public:
538         SHADER_NODE_CLASS(VectorTransformNode)
539
540         ustring type;
541         ustring convert_from;
542         ustring convert_to;
543         
544         static ShaderEnum type_enum;
545         static ShaderEnum convert_space_enum;
546 };
547
548 class BumpNode : public ShaderNode {
549 public:
550         SHADER_NODE_CLASS(BumpNode)
551         bool invert;
552 };
553
554 class RGBCurvesNode : public ShaderNode {
555 public:
556         SHADER_NODE_CLASS(RGBCurvesNode)
557         float4 curves[RAMP_TABLE_SIZE];
558 };
559
560 class VectorCurvesNode : public ShaderNode {
561 public:
562         SHADER_NODE_CLASS(VectorCurvesNode)
563         float4 curves[RAMP_TABLE_SIZE];
564 };
565
566 class RGBRampNode : public ShaderNode {
567 public:
568         SHADER_NODE_CLASS(RGBRampNode)
569         float4 ramp[RAMP_TABLE_SIZE];
570         bool interpolate;
571 };
572
573 class SetNormalNode : public ShaderNode {
574 public:
575         SHADER_NODE_CLASS(SetNormalNode)
576 };
577
578 class OSLScriptNode : public ShaderNode {
579 public:
580         SHADER_NODE_CLASS(OSLScriptNode)
581         string filepath;
582         string bytecode_hash;
583         
584         /* ShaderInput/ShaderOutput only stores a shallow string copy (const char *)!
585          * The actual socket names have to be stored externally to avoid memory errors. */
586         vector<ustring> input_names;
587         vector<ustring> output_names;
588 };
589
590 class NormalMapNode : public ShaderNode {
591 public:
592         SHADER_NODE_CLASS(NormalMapNode)
593         void attributes(Shader *shader, AttributeRequestSet *attributes);
594
595         ustring space;
596         static ShaderEnum space_enum;
597
598         ustring attribute;
599 };
600
601 class TangentNode : public ShaderNode {
602 public:
603         SHADER_NODE_CLASS(TangentNode)
604         void attributes(Shader *shader, AttributeRequestSet *attributes);
605
606         ustring direction_type;
607         static ShaderEnum direction_type_enum;
608
609         ustring axis;
610         static ShaderEnum axis_enum;
611
612         ustring attribute;
613 };
614
615 CCL_NAMESPACE_END
616
617 #endif /* __NODES_H__ */
618