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