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