d8f88cde2593be189a13af4e2a4f11c0c344febb
[blender-staging.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 Shadr;
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         string filename;
73         ustring color_space;
74         ustring projection;
75         float projection_blend;
76
77         static ShaderEnum color_space_enum;
78         static ShaderEnum projection_enum;
79 };
80
81 class EnvironmentTextureNode : public TextureNode {
82 public:
83         SHADER_NODE_NO_CLONE_CLASS(EnvironmentTextureNode)
84         ~EnvironmentTextureNode();
85         ShaderNode *clone() const;
86
87         ImageManager *image_manager;
88         int slot;
89         int is_float;
90         string filename;
91         ustring color_space;
92         ustring projection;
93
94         static ShaderEnum color_space_enum;
95         static ShaderEnum projection_enum;
96 };
97
98 class SkyTextureNode : public TextureNode {
99 public:
100         SHADER_NODE_CLASS(SkyTextureNode)
101
102         float3 sun_direction;
103         float turbidity;
104 };
105
106 class OutputNode : public ShaderNode {
107 public:
108         SHADER_NODE_CLASS(OutputNode)
109 };
110
111 class GradientTextureNode : public TextureNode {
112 public:
113         SHADER_NODE_CLASS(GradientTextureNode)
114
115         ustring type;
116         static ShaderEnum type_enum;
117 };
118
119 class NoiseTextureNode : public TextureNode {
120 public:
121         SHADER_NODE_CLASS(NoiseTextureNode)
122 };
123
124 class VoronoiTextureNode : public TextureNode {
125 public:
126         SHADER_NODE_CLASS(VoronoiTextureNode)
127
128         ustring coloring;
129
130         static ShaderEnum coloring_enum;
131 };
132
133 class MusgraveTextureNode : public TextureNode {
134 public:
135         SHADER_NODE_CLASS(MusgraveTextureNode)
136
137         ustring type;
138
139         static ShaderEnum type_enum;
140 };
141
142 class WaveTextureNode : public TextureNode {
143 public:
144         SHADER_NODE_CLASS(WaveTextureNode)
145
146         ustring type;
147         static ShaderEnum type_enum;
148 };
149
150 class MagicTextureNode : public TextureNode {
151 public:
152         SHADER_NODE_CLASS(MagicTextureNode)
153
154         int depth;
155 };
156
157 class CheckerTextureNode : public TextureNode {
158 public:
159         SHADER_NODE_CLASS(CheckerTextureNode)
160 };
161
162 class BrickTextureNode : public TextureNode {
163 public:
164         SHADER_NODE_CLASS(BrickTextureNode)
165         
166         float offset, squash;
167         int offset_frequency, squash_frequency;
168 };
169
170 class MappingNode : public ShaderNode {
171 public:
172         SHADER_NODE_CLASS(MappingNode)
173
174         TextureMapping tex_mapping;
175 };
176
177 class ConvertNode : public ShaderNode {
178 public:
179         ConvertNode(ShaderSocketType from, ShaderSocketType to);
180         SHADER_NODE_BASE_CLASS(ConvertNode)
181
182         ShaderSocketType from, to;
183 };
184
185 class ProxyNode : public ShaderNode {
186 public:
187         ProxyNode(ShaderSocketType from, ShaderSocketType to);
188         SHADER_NODE_BASE_CLASS(ProxyNode)
189
190         ShaderSocketType from, to;
191 };
192
193 class BsdfNode : public ShaderNode {
194 public:
195         SHADER_NODE_CLASS(BsdfNode)
196
197         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2, ShaderInput *param3 = NULL);
198
199         ClosureType closure;
200 };
201
202 class WardBsdfNode : public BsdfNode {
203 public:
204         SHADER_NODE_CLASS(WardBsdfNode)
205         void attributes(AttributeRequestSet *attributes);
206 };
207
208 class DiffuseBsdfNode : public BsdfNode {
209 public:
210         SHADER_NODE_CLASS(DiffuseBsdfNode)
211 };
212
213 class TranslucentBsdfNode : public BsdfNode {
214 public:
215         SHADER_NODE_CLASS(TranslucentBsdfNode)
216 };
217
218 class TransparentBsdfNode : public BsdfNode {
219 public:
220         SHADER_NODE_CLASS(TransparentBsdfNode)
221 };
222
223 class VelvetBsdfNode : public BsdfNode {
224 public:
225         SHADER_NODE_CLASS(VelvetBsdfNode)
226 };
227
228 class GlossyBsdfNode : public BsdfNode {
229 public:
230         SHADER_NODE_CLASS(GlossyBsdfNode)
231
232         ustring distribution;
233         static ShaderEnum distribution_enum;
234 };
235
236 class GlassBsdfNode : public BsdfNode {
237 public:
238         SHADER_NODE_CLASS(GlassBsdfNode)
239
240         ustring distribution;
241         static ShaderEnum distribution_enum;
242 };
243
244 class RefractionBsdfNode : public BsdfNode {
245 public:
246         SHADER_NODE_CLASS(RefractionBsdfNode)
247
248         ustring distribution;
249         static ShaderEnum distribution_enum;
250 };
251
252 class EmissionNode : public ShaderNode {
253 public:
254         SHADER_NODE_CLASS(EmissionNode)
255
256         bool total_power;
257 };
258
259 class BackgroundNode : public ShaderNode {
260 public:
261         SHADER_NODE_CLASS(BackgroundNode)
262 };
263
264 class HoldoutNode : public ShaderNode {
265 public:
266         SHADER_NODE_CLASS(HoldoutNode)
267 };
268
269 class AmbientOcclusionNode : public ShaderNode {
270 public:
271         SHADER_NODE_CLASS(AmbientOcclusionNode)
272 };
273
274 class VolumeNode : public ShaderNode {
275 public:
276         SHADER_NODE_CLASS(VolumeNode)
277
278         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
279
280         ClosureType closure;
281 };
282
283 class TransparentVolumeNode : public VolumeNode {
284 public:
285         SHADER_NODE_CLASS(TransparentVolumeNode)
286 };
287
288 class IsotropicVolumeNode : public VolumeNode {
289 public:
290         SHADER_NODE_CLASS(IsotropicVolumeNode)
291 };
292
293 class GeometryNode : public ShaderNode {
294 public:
295         SHADER_NODE_CLASS(GeometryNode)
296         void attributes(AttributeRequestSet *attributes);
297 };
298
299 class TextureCoordinateNode : public ShaderNode {
300 public:
301         SHADER_NODE_CLASS(TextureCoordinateNode)
302         void attributes(AttributeRequestSet *attributes);
303         
304         bool from_dupli;
305 };
306
307 class LightPathNode : public ShaderNode {
308 public:
309         SHADER_NODE_CLASS(LightPathNode)
310 };
311
312 class LightFalloffNode : public ShaderNode {
313 public:
314         SHADER_NODE_CLASS(LightFalloffNode)
315 };
316
317 class ObjectInfoNode : public ShaderNode {
318 public:
319         SHADER_NODE_CLASS(ObjectInfoNode)
320 };
321
322 class ParticleInfoNode : public ShaderNode {
323 public:
324         SHADER_NODE_CLASS(ParticleInfoNode)
325         void attributes(AttributeRequestSet *attributes);
326 };
327
328 class ValueNode : public ShaderNode {
329 public:
330         SHADER_NODE_CLASS(ValueNode)
331
332         float value;
333 };
334
335 class ColorNode : public ShaderNode {
336 public:
337         SHADER_NODE_CLASS(ColorNode)
338
339         float3 value;
340 };
341
342 class AddClosureNode : public ShaderNode {
343 public:
344         SHADER_NODE_CLASS(AddClosureNode)
345 };
346
347 class MixClosureNode : public ShaderNode {
348 public:
349         SHADER_NODE_CLASS(MixClosureNode)
350 };
351
352 class InvertNode : public ShaderNode {
353 public:
354         SHADER_NODE_CLASS(InvertNode)
355 };
356
357 class MixNode : public ShaderNode {
358 public:
359         SHADER_NODE_CLASS(MixNode)
360
361         bool use_clamp;
362
363         ustring type;
364         static ShaderEnum type_enum;
365 };
366
367 class CombineRGBNode : public ShaderNode {
368 public:
369         SHADER_NODE_CLASS(CombineRGBNode)
370 };
371
372 class GammaNode : public ShaderNode {
373 public:
374         SHADER_NODE_CLASS(GammaNode)
375 };
376
377 class BrightContrastNode : public ShaderNode {
378 public:
379         SHADER_NODE_CLASS(BrightContrastNode)
380 };
381
382 class SeparateRGBNode : public ShaderNode {
383 public:
384         SHADER_NODE_CLASS(SeparateRGBNode)
385 };
386
387 class HSVNode : public ShaderNode {
388 public:
389         SHADER_NODE_CLASS(HSVNode)
390 };
391
392 class AttributeNode : public ShaderNode {
393 public:
394         SHADER_NODE_CLASS(AttributeNode)
395         void attributes(AttributeRequestSet *attributes);
396
397         ustring attribute;
398 };
399
400 class CameraNode : public ShaderNode {
401 public:
402         SHADER_NODE_CLASS(CameraNode)
403 };
404
405 class FresnelNode : public ShaderNode {
406 public:
407         SHADER_NODE_CLASS(FresnelNode)
408 };
409
410 class LayerWeightNode : public ShaderNode {
411 public:
412         SHADER_NODE_CLASS(LayerWeightNode)
413 };
414
415 class MathNode : public ShaderNode {
416 public:
417         SHADER_NODE_CLASS(MathNode)
418
419         bool use_clamp;
420
421         ustring type;
422         static ShaderEnum type_enum;
423 };
424
425 class NormalNode : public ShaderNode {
426 public:
427         SHADER_NODE_CLASS(NormalNode)
428
429         float3 direction;
430 };
431
432 class VectorMathNode : public ShaderNode {
433 public:
434         SHADER_NODE_CLASS(VectorMathNode)
435
436         ustring type;
437         static ShaderEnum type_enum;
438 };
439
440 class BumpNode : public ShaderNode {
441 public:
442         SHADER_NODE_CLASS(BumpNode)
443 };
444
445 class RGBCurvesNode : public ShaderNode {
446 public:
447         SHADER_NODE_CLASS(RGBCurvesNode)
448         float4 curves[RAMP_TABLE_SIZE];
449 };
450
451 class RGBRampNode : public ShaderNode {
452 public:
453         SHADER_NODE_CLASS(RGBRampNode)
454         float4 ramp[RAMP_TABLE_SIZE];
455 };
456
457 class SetNormalNode : public ShaderNode {
458 public:
459         SHADER_NODE_CLASS(SetNormalNode)
460 };
461
462 class OSLScriptNode : public ShaderNode {
463 public:
464         SHADER_NODE_CLASS(OSLScriptNode)
465         string filepath;
466         string bytecode_hash;
467         
468         /* ShaderInput/ShaderOutput only stores a shallow string copy (const char *)!
469          * The actual socket names have to be stored externally to avoid memory errors. */
470         vector<ustring> input_names;
471         vector<ustring> output_names;
472 };
473
474 class NormalMapNode : public ShaderNode {
475 public:
476         SHADER_NODE_CLASS(NormalMapNode)
477         void attributes(AttributeRequestSet *attributes);
478
479         ustring space;
480         static ShaderEnum space_enum;
481
482         ustring attribute;
483 };
484
485 class TangentNode : public ShaderNode {
486 public:
487         SHADER_NODE_CLASS(TangentNode)
488         void attributes(AttributeRequestSet *attributes);
489
490         ustring direction_type;
491         static ShaderEnum direction_type_enum;
492
493         ustring axis;
494         static ShaderEnum axis_enum;
495
496         ustring attribute;
497 };
498
499 CCL_NAMESPACE_END
500
501 #endif /* __NODES_H__ */
502