Cycles / HSV Separator and Combine node:
[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 CombineHSVNode : public ShaderNode {
411 public:
412         SHADER_NODE_CLASS(CombineHSVNode)
413 };
414
415 class GammaNode : public ShaderNode {
416 public:
417         SHADER_NODE_CLASS(GammaNode)
418 };
419
420 class BrightContrastNode : public ShaderNode {
421 public:
422         SHADER_NODE_CLASS(BrightContrastNode)
423 };
424
425 class SeparateRGBNode : public ShaderNode {
426 public:
427         SHADER_NODE_CLASS(SeparateRGBNode)
428 };
429
430 class SeparateHSVNode : public ShaderNode {
431 public:
432         SHADER_NODE_CLASS(SeparateHSVNode)
433 };
434
435 class HSVNode : public ShaderNode {
436 public:
437         SHADER_NODE_CLASS(HSVNode)
438 };
439
440 class AttributeNode : public ShaderNode {
441 public:
442         SHADER_NODE_CLASS(AttributeNode)
443         void attributes(AttributeRequestSet *attributes);
444
445         ustring attribute;
446 };
447
448 class CameraNode : public ShaderNode {
449 public:
450         SHADER_NODE_CLASS(CameraNode)
451 };
452
453 class FresnelNode : public ShaderNode {
454 public:
455         SHADER_NODE_CLASS(FresnelNode)
456 };
457
458 class LayerWeightNode : public ShaderNode {
459 public:
460         SHADER_NODE_CLASS(LayerWeightNode)
461 };
462
463 class WireframeNode : public ShaderNode {
464 public:
465         SHADER_NODE_CLASS(WireframeNode)
466         
467         bool use_pixel_size;
468 };
469
470 class WavelengthNode : public ShaderNode {
471 public:
472         SHADER_NODE_CLASS(WavelengthNode)
473 };
474
475 class BlackbodyNode : public ShaderNode {
476 public:
477         SHADER_NODE_CLASS(BlackbodyNode)
478         
479         bool has_converter_blackbody() { return true; }
480 };
481
482 class MathNode : public ShaderNode {
483 public:
484         SHADER_NODE_CLASS(MathNode)
485
486         bool use_clamp;
487
488         ustring type;
489         static ShaderEnum type_enum;
490 };
491
492 class NormalNode : public ShaderNode {
493 public:
494         SHADER_NODE_CLASS(NormalNode)
495
496         float3 direction;
497 };
498
499 class VectorMathNode : public ShaderNode {
500 public:
501         SHADER_NODE_CLASS(VectorMathNode)
502
503         ustring type;
504         static ShaderEnum type_enum;
505 };
506
507 class VectorTransformNode : public ShaderNode {
508 public:
509         SHADER_NODE_CLASS(VectorTransformNode)
510
511         ustring type;
512         ustring convert_from;
513         ustring convert_to;
514         
515         static ShaderEnum type_enum;
516         static ShaderEnum convert_space_enum;
517 };
518
519 class BumpNode : public ShaderNode {
520 public:
521         SHADER_NODE_CLASS(BumpNode)
522         bool invert;
523 };
524
525 class RGBCurvesNode : public ShaderNode {
526 public:
527         SHADER_NODE_CLASS(RGBCurvesNode)
528         float4 curves[RAMP_TABLE_SIZE];
529 };
530
531 class VectorCurvesNode : public ShaderNode {
532 public:
533         SHADER_NODE_CLASS(VectorCurvesNode)
534         float4 curves[RAMP_TABLE_SIZE];
535 };
536
537 class RGBRampNode : public ShaderNode {
538 public:
539         SHADER_NODE_CLASS(RGBRampNode)
540         float4 ramp[RAMP_TABLE_SIZE];
541         bool interpolate;
542 };
543
544 class SetNormalNode : public ShaderNode {
545 public:
546         SHADER_NODE_CLASS(SetNormalNode)
547 };
548
549 class OSLScriptNode : public ShaderNode {
550 public:
551         SHADER_NODE_CLASS(OSLScriptNode)
552         string filepath;
553         string bytecode_hash;
554         
555         /* ShaderInput/ShaderOutput only stores a shallow string copy (const char *)!
556          * The actual socket names have to be stored externally to avoid memory errors. */
557         vector<ustring> input_names;
558         vector<ustring> output_names;
559 };
560
561 class NormalMapNode : public ShaderNode {
562 public:
563         SHADER_NODE_CLASS(NormalMapNode)
564         void attributes(AttributeRequestSet *attributes);
565
566         ustring space;
567         static ShaderEnum space_enum;
568
569         ustring attribute;
570 };
571
572 class TangentNode : public ShaderNode {
573 public:
574         SHADER_NODE_CLASS(TangentNode)
575         void attributes(AttributeRequestSet *attributes);
576
577         ustring direction_type;
578         static ShaderEnum direction_type_enum;
579
580         ustring axis;
581         static ShaderEnum axis_enum;
582
583         ustring attribute;
584 };
585
586 CCL_NAMESPACE_END
587
588 #endif /* __NODES_H__ */
589