670d8da7825feb5f0a81d37a0662d3202cad58dc
[blender.git] / intern / cycles / render / nodes.h
1 /*
2  * Copyright 2011, Blender Foundation.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  */
18
19 #ifndef __NODES_H__
20 #define __NODES_H__
21
22 #include "graph.h"
23
24 #include "util_string.h"
25
26 CCL_NAMESPACE_BEGIN
27
28 class ImageManager;
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         void compile(OSLCompiler &compiler);
40
41         float3 translation;
42         float3 rotation;
43         float3 scale;
44
45         float3 min, max;
46         bool use_minmax;
47
48         enum Mapping { NONE = 0, X = 1, Y = 2, Z = 3 };
49         Mapping x_mapping, y_mapping, z_mapping;
50
51         enum Projection { FLAT, CUBE, TUBE, SPHERE };
52         Projection projection;
53 };
54
55 /* Nodes */
56
57 class TextureNode : public ShaderNode {
58 public:
59         TextureNode(const char *name_) : ShaderNode(name_) {}
60         TextureMapping tex_mapping;
61 };
62
63 class ImageTextureNode : public TextureNode {
64 public:
65         SHADER_NODE_NO_CLONE_CLASS(ImageTextureNode)
66         ~ImageTextureNode();
67         ShaderNode *clone() const;
68
69         ImageManager *image_manager;
70         int slot;
71         int is_float;
72         bool is_linear;
73         string filename;
74         void *builtin_data;
75         ustring color_space;
76         ustring projection;
77         float projection_blend;
78         bool animated;
79
80         static ShaderEnum color_space_enum;
81         static ShaderEnum projection_enum;
82 };
83
84 class EnvironmentTextureNode : public TextureNode {
85 public:
86         SHADER_NODE_NO_CLONE_CLASS(EnvironmentTextureNode)
87         ~EnvironmentTextureNode();
88         ShaderNode *clone() const;
89
90         ImageManager *image_manager;
91         int slot;
92         int is_float;
93         bool is_linear;
94         string filename;
95         void *builtin_data;
96         ustring color_space;
97         ustring projection;
98         bool animated;
99
100         static ShaderEnum color_space_enum;
101         static ShaderEnum projection_enum;
102 };
103
104 class SkyTextureNode : public TextureNode {
105 public:
106         SHADER_NODE_CLASS(SkyTextureNode)
107
108         float3 sun_direction;
109         float turbidity;
110 };
111
112 class OutputNode : public ShaderNode {
113 public:
114         SHADER_NODE_CLASS(OutputNode)
115 };
116
117 class GradientTextureNode : public TextureNode {
118 public:
119         SHADER_NODE_CLASS(GradientTextureNode)
120
121         ustring type;
122         static ShaderEnum type_enum;
123 };
124
125 class NoiseTextureNode : public TextureNode {
126 public:
127         SHADER_NODE_CLASS(NoiseTextureNode)
128 };
129
130 class VoronoiTextureNode : public TextureNode {
131 public:
132         SHADER_NODE_CLASS(VoronoiTextureNode)
133
134         ustring coloring;
135
136         static ShaderEnum coloring_enum;
137 };
138
139 class MusgraveTextureNode : public TextureNode {
140 public:
141         SHADER_NODE_CLASS(MusgraveTextureNode)
142
143         ustring type;
144
145         static ShaderEnum type_enum;
146 };
147
148 class WaveTextureNode : public TextureNode {
149 public:
150         SHADER_NODE_CLASS(WaveTextureNode)
151
152         ustring type;
153         static ShaderEnum type_enum;
154 };
155
156 class MagicTextureNode : public TextureNode {
157 public:
158         SHADER_NODE_CLASS(MagicTextureNode)
159
160         int depth;
161 };
162
163 class CheckerTextureNode : public TextureNode {
164 public:
165         SHADER_NODE_CLASS(CheckerTextureNode)
166 };
167
168 class BrickTextureNode : public TextureNode {
169 public:
170         SHADER_NODE_CLASS(BrickTextureNode)
171         
172         float offset, squash;
173         int offset_frequency, squash_frequency;
174 };
175
176 class MappingNode : public ShaderNode {
177 public:
178         SHADER_NODE_CLASS(MappingNode)
179
180         TextureMapping tex_mapping;
181 };
182
183 class ConvertNode : public ShaderNode {
184 public:
185         ConvertNode(ShaderSocketType from, ShaderSocketType to, bool autoconvert = false);
186         SHADER_NODE_BASE_CLASS(ConvertNode)
187
188         ShaderSocketType from, to;
189 };
190
191 class ProxyNode : public ShaderNode {
192 public:
193         ProxyNode(ShaderSocketType type);
194         SHADER_NODE_BASE_CLASS(ProxyNode)
195
196         ShaderSocketType type;
197 };
198
199 class BsdfNode : public ShaderNode {
200 public:
201         BsdfNode(bool scattering = false);
202         SHADER_NODE_BASE_CLASS(BsdfNode);
203
204         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2, ShaderInput *param3 = NULL);
205
206         ClosureType closure;
207         bool scattering;
208 };
209
210 class WardBsdfNode : public BsdfNode {
211 public:
212         SHADER_NODE_CLASS(WardBsdfNode)
213         void attributes(AttributeRequestSet *attributes);
214 };
215
216 class DiffuseBsdfNode : public BsdfNode {
217 public:
218         SHADER_NODE_CLASS(DiffuseBsdfNode)
219 };
220
221 class TranslucentBsdfNode : public BsdfNode {
222 public:
223         SHADER_NODE_CLASS(TranslucentBsdfNode)
224 };
225
226 class TransparentBsdfNode : public BsdfNode {
227 public:
228         SHADER_NODE_CLASS(TransparentBsdfNode)
229
230         bool has_surface_transparent() { return true; }
231 };
232
233 class VelvetBsdfNode : public BsdfNode {
234 public:
235         SHADER_NODE_CLASS(VelvetBsdfNode)
236 };
237
238 class GlossyBsdfNode : public BsdfNode {
239 public:
240         SHADER_NODE_CLASS(GlossyBsdfNode)
241
242         ustring distribution;
243         static ShaderEnum distribution_enum;
244 };
245
246 class GlassBsdfNode : public BsdfNode {
247 public:
248         SHADER_NODE_CLASS(GlassBsdfNode)
249
250         ustring distribution;
251         static ShaderEnum distribution_enum;
252 };
253
254 class RefractionBsdfNode : public BsdfNode {
255 public:
256         SHADER_NODE_CLASS(RefractionBsdfNode)
257
258         ustring distribution;
259         static ShaderEnum distribution_enum;
260 };
261
262 class ToonBsdfNode : public BsdfNode {
263 public:
264         SHADER_NODE_CLASS(ToonBsdfNode)
265
266         ustring component;
267         static ShaderEnum component_enum;
268 };
269
270 class SubsurfaceScatteringNode : public BsdfNode {
271 public:
272         SHADER_NODE_CLASS(SubsurfaceScatteringNode)
273         bool has_surface_bssrdf() { return true; }
274 };
275
276 class EmissionNode : public ShaderNode {
277 public:
278         SHADER_NODE_CLASS(EmissionNode)
279
280         bool has_surface_emission() { return true; }
281
282         bool total_power;
283 };
284
285 class BackgroundNode : public ShaderNode {
286 public:
287         SHADER_NODE_CLASS(BackgroundNode)
288 };
289
290 class HoldoutNode : public ShaderNode {
291 public:
292         SHADER_NODE_CLASS(HoldoutNode)
293 };
294
295 class AmbientOcclusionNode : public ShaderNode {
296 public:
297         SHADER_NODE_CLASS(AmbientOcclusionNode)
298 };
299
300 class VolumeNode : public ShaderNode {
301 public:
302         SHADER_NODE_CLASS(VolumeNode)
303
304         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
305
306         ClosureType closure;
307 };
308
309 class TransparentVolumeNode : public VolumeNode {
310 public:
311         SHADER_NODE_CLASS(TransparentVolumeNode)
312 };
313
314 class IsotropicVolumeNode : public VolumeNode {
315 public:
316         SHADER_NODE_CLASS(IsotropicVolumeNode)
317 };
318
319 class GeometryNode : public ShaderNode {
320 public:
321         SHADER_NODE_CLASS(GeometryNode)
322         void attributes(AttributeRequestSet *attributes);
323 };
324
325 class TextureCoordinateNode : public ShaderNode {
326 public:
327         SHADER_NODE_CLASS(TextureCoordinateNode)
328         void attributes(AttributeRequestSet *attributes);
329         
330         bool from_dupli;
331 };
332
333 class LightPathNode : public ShaderNode {
334 public:
335         SHADER_NODE_CLASS(LightPathNode)
336 };
337
338 class LightFalloffNode : public ShaderNode {
339 public:
340         SHADER_NODE_CLASS(LightFalloffNode)
341 };
342
343 class ObjectInfoNode : public ShaderNode {
344 public:
345         SHADER_NODE_CLASS(ObjectInfoNode)
346 };
347
348 class ParticleInfoNode : public ShaderNode {
349 public:
350         SHADER_NODE_CLASS(ParticleInfoNode)
351         void attributes(AttributeRequestSet *attributes);
352 };
353
354 class HairInfoNode : public ShaderNode {
355 public:
356         SHADER_NODE_CLASS(HairInfoNode)
357
358         void attributes(AttributeRequestSet *attributes);
359 };
360
361 class ValueNode : public ShaderNode {
362 public:
363         SHADER_NODE_CLASS(ValueNode)
364
365         float value;
366 };
367
368 class ColorNode : public ShaderNode {
369 public:
370         SHADER_NODE_CLASS(ColorNode)
371
372         float3 value;
373 };
374
375 class AddClosureNode : public ShaderNode {
376 public:
377         SHADER_NODE_CLASS(AddClosureNode)
378 };
379
380 class MixClosureNode : public ShaderNode {
381 public:
382         SHADER_NODE_CLASS(MixClosureNode)
383 };
384
385 class MixClosureWeightNode : public ShaderNode {
386 public:
387         SHADER_NODE_CLASS(MixClosureWeightNode);
388 };
389
390 class InvertNode : public ShaderNode {
391 public:
392         SHADER_NODE_CLASS(InvertNode)
393 };
394
395 class MixNode : public ShaderNode {
396 public:
397         SHADER_NODE_CLASS(MixNode)
398
399         bool use_clamp;
400
401         ustring type;
402         static ShaderEnum type_enum;
403 };
404
405 class CombineRGBNode : public ShaderNode {
406 public:
407         SHADER_NODE_CLASS(CombineRGBNode)
408 };
409
410 class GammaNode : public ShaderNode {
411 public:
412         SHADER_NODE_CLASS(GammaNode)
413 };
414
415 class BrightContrastNode : public ShaderNode {
416 public:
417         SHADER_NODE_CLASS(BrightContrastNode)
418 };
419
420 class SeparateRGBNode : public ShaderNode {
421 public:
422         SHADER_NODE_CLASS(SeparateRGBNode)
423 };
424
425 class HSVNode : public ShaderNode {
426 public:
427         SHADER_NODE_CLASS(HSVNode)
428 };
429
430 class AttributeNode : public ShaderNode {
431 public:
432         SHADER_NODE_CLASS(AttributeNode)
433         void attributes(AttributeRequestSet *attributes);
434
435         ustring attribute;
436 };
437
438 class CameraNode : public ShaderNode {
439 public:
440         SHADER_NODE_CLASS(CameraNode)
441 };
442
443 class FresnelNode : public ShaderNode {
444 public:
445         SHADER_NODE_CLASS(FresnelNode)
446 };
447
448 class LayerWeightNode : public ShaderNode {
449 public:
450         SHADER_NODE_CLASS(LayerWeightNode)
451 };
452
453 class WireframeNode : public ShaderNode {
454 public:
455         SHADER_NODE_CLASS(WireframeNode)
456         
457         bool use_pixel_size;
458 };
459
460 class WavelengthNode : public ShaderNode {
461 public:
462         SHADER_NODE_CLASS(WavelengthNode)
463 };
464
465 class BlackbodyNode : public ShaderNode {
466 public:
467         SHADER_NODE_CLASS(BlackbodyNode)
468         
469         bool has_converter_blackbody() { return true; }
470 };
471
472 class MathNode : public ShaderNode {
473 public:
474         SHADER_NODE_CLASS(MathNode)
475
476         bool use_clamp;
477
478         ustring type;
479         static ShaderEnum type_enum;
480 };
481
482 class NormalNode : public ShaderNode {
483 public:
484         SHADER_NODE_CLASS(NormalNode)
485
486         float3 direction;
487 };
488
489 class VectorMathNode : public ShaderNode {
490 public:
491         SHADER_NODE_CLASS(VectorMathNode)
492
493         ustring type;
494         static ShaderEnum type_enum;
495 };
496
497 class VectorTransformNode : public ShaderNode {
498 public:
499         SHADER_NODE_CLASS(VectorTransformNode)
500
501         ustring type;
502         ustring convert_from;
503         ustring convert_to;
504         
505         static ShaderEnum type_enum;
506         static ShaderEnum convert_from_enum;
507         static ShaderEnum convert_to_enum;
508 };
509
510 class BumpNode : public ShaderNode {
511 public:
512         SHADER_NODE_CLASS(BumpNode)
513         bool invert;
514 };
515
516 class RGBCurvesNode : public ShaderNode {
517 public:
518         SHADER_NODE_CLASS(RGBCurvesNode)
519         float4 curves[RAMP_TABLE_SIZE];
520 };
521
522 class VectorCurvesNode : public ShaderNode {
523 public:
524         SHADER_NODE_CLASS(VectorCurvesNode)
525         float4 curves[RAMP_TABLE_SIZE];
526 };
527
528 class RGBRampNode : public ShaderNode {
529 public:
530         SHADER_NODE_CLASS(RGBRampNode)
531         float4 ramp[RAMP_TABLE_SIZE];
532         bool interpolate;
533 };
534
535 class SetNormalNode : public ShaderNode {
536 public:
537         SHADER_NODE_CLASS(SetNormalNode)
538 };
539
540 class OSLScriptNode : public ShaderNode {
541 public:
542         SHADER_NODE_CLASS(OSLScriptNode)
543         string filepath;
544         string bytecode_hash;
545         
546         /* ShaderInput/ShaderOutput only stores a shallow string copy (const char *)!
547          * The actual socket names have to be stored externally to avoid memory errors. */
548         vector<ustring> input_names;
549         vector<ustring> output_names;
550 };
551
552 class NormalMapNode : public ShaderNode {
553 public:
554         SHADER_NODE_CLASS(NormalMapNode)
555         void attributes(AttributeRequestSet *attributes);
556
557         ustring space;
558         static ShaderEnum space_enum;
559
560         ustring attribute;
561 };
562
563 class TangentNode : public ShaderNode {
564 public:
565         SHADER_NODE_CLASS(TangentNode)
566         void attributes(AttributeRequestSet *attributes);
567
568         ustring direction_type;
569         static ShaderEnum direction_type_enum;
570
571         ustring axis;
572         static ShaderEnum axis_enum;
573
574         ustring attribute;
575 };
576
577 CCL_NAMESPACE_END
578
579 #endif /* __NODES_H__ */
580