Sequencer: invalidate current frame cache on sequence transform
[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 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
40         float3 translation;
41         float3 rotation;
42         float3 scale;
43
44         float3 min, max;
45         bool use_minmax;
46
47         enum Mapping { NONE = 0, X = 1, Y = 2, Z = 3 };
48         Mapping x_mapping, y_mapping, z_mapping;
49
50         enum Projection { FLAT, CUBE, TUBE, SPHERE };
51         Projection projection;
52 };
53
54 /* Nodes */
55
56 class TextureNode : public ShaderNode {
57 public:
58         TextureNode(const char *name_) : ShaderNode(name_) {}
59         TextureMapping tex_mapping;
60 };
61
62 class ImageTextureNode : public TextureNode {
63 public:
64         SHADER_NODE_NO_CLONE_CLASS(ImageTextureNode)
65         ~ImageTextureNode();
66         ShaderNode *clone() const;
67
68         ImageManager *image_manager;
69         int slot;
70         bool is_float;
71         string filename;
72         ustring color_space;
73
74         static ShaderEnum color_space_enum;
75 };
76
77 class EnvironmentTextureNode : public TextureNode {
78 public:
79         SHADER_NODE_NO_CLONE_CLASS(EnvironmentTextureNode)
80         ~EnvironmentTextureNode();
81         ShaderNode *clone() const;
82
83         ImageManager *image_manager;
84         int slot;
85         bool is_float;
86         string filename;
87         ustring color_space;
88         ustring projection;
89
90         static ShaderEnum color_space_enum;
91         static ShaderEnum projection_enum;
92 };
93
94 class SkyTextureNode : public TextureNode {
95 public:
96         SHADER_NODE_CLASS(SkyTextureNode)
97
98         float3 sun_direction;
99         float turbidity;
100 };
101
102 class OutputNode : public ShaderNode {
103 public:
104         SHADER_NODE_CLASS(OutputNode)
105 };
106
107 class GradientTextureNode : public TextureNode {
108 public:
109         SHADER_NODE_CLASS(GradientTextureNode)
110
111         ustring type;
112         static ShaderEnum type_enum;
113 };
114
115 class NoiseTextureNode : public TextureNode {
116 public:
117         SHADER_NODE_CLASS(NoiseTextureNode)
118 };
119
120 class VoronoiTextureNode : public TextureNode {
121 public:
122         SHADER_NODE_CLASS(VoronoiTextureNode)
123
124         ustring coloring;
125
126         static ShaderEnum coloring_enum;
127 };
128
129 class MusgraveTextureNode : public TextureNode {
130 public:
131         SHADER_NODE_CLASS(MusgraveTextureNode)
132
133         ustring type;
134
135         static ShaderEnum type_enum;
136 };
137
138 class WaveTextureNode : public TextureNode {
139 public:
140         SHADER_NODE_CLASS(WaveTextureNode)
141
142         ustring type;
143         static ShaderEnum type_enum;
144 };
145
146 class MagicTextureNode : public TextureNode {
147 public:
148         SHADER_NODE_CLASS(MagicTextureNode)
149
150         int depth;
151 };
152
153 class CheckerTextureNode : public TextureNode {
154 public:
155         SHADER_NODE_CLASS(CheckerTextureNode)
156 };
157
158 class MappingNode : public ShaderNode {
159 public:
160         SHADER_NODE_CLASS(MappingNode)
161
162         TextureMapping tex_mapping;
163 };
164
165 class ConvertNode : public ShaderNode {
166 public:
167         ConvertNode(ShaderSocketType from, ShaderSocketType to);
168         SHADER_NODE_BASE_CLASS(ConvertNode)
169
170         ShaderSocketType from, to;
171 };
172
173 class ProxyNode : public ShaderNode {
174 public:
175         ProxyNode(ShaderSocketType from, ShaderSocketType to);
176         SHADER_NODE_BASE_CLASS(ProxyNode)
177
178         ShaderSocketType from, to;
179 };
180
181 class BsdfNode : public ShaderNode {
182 public:
183         SHADER_NODE_CLASS(BsdfNode)
184
185         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
186
187         ClosureType closure;
188 };
189
190 class WardBsdfNode : public BsdfNode {
191 public:
192         SHADER_NODE_CLASS(WardBsdfNode)
193 };
194
195 class DiffuseBsdfNode : public BsdfNode {
196 public:
197         SHADER_NODE_CLASS(DiffuseBsdfNode)
198 };
199
200 class TranslucentBsdfNode : public BsdfNode {
201 public:
202         SHADER_NODE_CLASS(TranslucentBsdfNode)
203 };
204
205 class TransparentBsdfNode : public BsdfNode {
206 public:
207         SHADER_NODE_CLASS(TransparentBsdfNode)
208 };
209
210 class VelvetBsdfNode : public BsdfNode {
211 public:
212         SHADER_NODE_CLASS(VelvetBsdfNode)
213 };
214
215 class GlossyBsdfNode : public BsdfNode {
216 public:
217         SHADER_NODE_CLASS(GlossyBsdfNode)
218
219         ustring distribution;
220         static ShaderEnum distribution_enum;
221 };
222
223 class GlassBsdfNode : public BsdfNode {
224 public:
225         SHADER_NODE_CLASS(GlassBsdfNode)
226
227         ustring distribution;
228         static ShaderEnum distribution_enum;
229 };
230
231 class EmissionNode : public ShaderNode {
232 public:
233         SHADER_NODE_CLASS(EmissionNode)
234
235         bool total_power;
236 };
237
238 class BackgroundNode : public ShaderNode {
239 public:
240         SHADER_NODE_CLASS(BackgroundNode)
241 };
242
243 class HoldoutNode : public ShaderNode {
244 public:
245         SHADER_NODE_CLASS(HoldoutNode)
246 };
247
248 class VolumeNode : public ShaderNode {
249 public:
250         SHADER_NODE_CLASS(VolumeNode)
251
252         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
253
254         ClosureType closure;
255 };
256
257 class TransparentVolumeNode : public VolumeNode {
258 public:
259         SHADER_NODE_CLASS(TransparentVolumeNode)
260 };
261
262 class IsotropicVolumeNode : public VolumeNode {
263 public:
264         SHADER_NODE_CLASS(IsotropicVolumeNode)
265 };
266
267 class GeometryNode : public ShaderNode {
268 public:
269         SHADER_NODE_CLASS(GeometryNode)
270 };
271
272 class TextureCoordinateNode : public ShaderNode {
273 public:
274         SHADER_NODE_CLASS(TextureCoordinateNode)
275         void attributes(AttributeRequestSet *attributes);
276 };
277
278 class LightPathNode : public ShaderNode {
279 public:
280         SHADER_NODE_CLASS(LightPathNode)
281 };
282
283 class LightFalloffNode : public ShaderNode {
284 public:
285         SHADER_NODE_CLASS(LightFalloffNode)
286 };
287
288 class ObjectInfoNode : public ShaderNode {
289 public:
290         SHADER_NODE_CLASS(ObjectInfoNode)
291 };
292
293 class ParticleInfoNode : public ShaderNode {
294 public:
295         SHADER_NODE_CLASS(ParticleInfoNode)
296         void attributes(AttributeRequestSet *attributes);
297 };
298
299 class ValueNode : public ShaderNode {
300 public:
301         SHADER_NODE_CLASS(ValueNode)
302
303         float value;
304 };
305
306 class ColorNode : public ShaderNode {
307 public:
308         SHADER_NODE_CLASS(ColorNode)
309
310         float3 value;
311 };
312
313 class AddClosureNode : public ShaderNode {
314 public:
315         SHADER_NODE_CLASS(AddClosureNode)
316 };
317
318 class MixClosureNode : public ShaderNode {
319 public:
320         SHADER_NODE_CLASS(MixClosureNode)
321 };
322
323 class InvertNode : public ShaderNode {
324 public:
325         SHADER_NODE_CLASS(InvertNode)
326 };
327
328 class MixNode : public ShaderNode {
329 public:
330         SHADER_NODE_CLASS(MixNode)
331
332         ustring type;
333         static ShaderEnum type_enum;
334 };
335
336 class CombineRGBNode : public ShaderNode {
337 public:
338         SHADER_NODE_CLASS(CombineRGBNode)
339 };
340
341 class GammaNode : public ShaderNode {
342 public:
343         SHADER_NODE_CLASS(GammaNode)
344 };
345
346 class BrightContrastNode : public ShaderNode {
347 public:
348         SHADER_NODE_CLASS(BrightContrastNode)
349 };
350
351 class SeparateRGBNode : public ShaderNode {
352 public:
353         SHADER_NODE_CLASS(SeparateRGBNode)
354 };
355
356 class HSVNode : public ShaderNode {
357 public:
358         SHADER_NODE_CLASS(HSVNode)
359 };
360
361 class AttributeNode : public ShaderNode {
362 public:
363         SHADER_NODE_CLASS(AttributeNode)
364         void attributes(AttributeRequestSet *attributes);
365
366         ustring attribute;
367 };
368
369 class CameraNode : public ShaderNode {
370 public:
371         SHADER_NODE_CLASS(CameraNode)
372 };
373
374 class FresnelNode : public ShaderNode {
375 public:
376         SHADER_NODE_CLASS(FresnelNode)
377 };
378
379 class LayerWeightNode : public ShaderNode {
380 public:
381         SHADER_NODE_CLASS(LayerWeightNode)
382 };
383
384 class MathNode : public ShaderNode {
385 public:
386         SHADER_NODE_CLASS(MathNode)
387
388         ustring type;
389         static ShaderEnum type_enum;
390 };
391
392 class NormalNode : public ShaderNode {
393 public:
394         SHADER_NODE_CLASS(NormalNode)
395
396         float3 direction;
397 };
398
399 class VectorMathNode : public ShaderNode {
400 public:
401         SHADER_NODE_CLASS(VectorMathNode)
402
403         ustring type;
404         static ShaderEnum type_enum;
405 };
406
407 class BumpNode : public ShaderNode {
408 public:
409         SHADER_NODE_CLASS(BumpNode)
410 };
411
412 class RGBCurvesNode : public ShaderNode {
413 public:
414         SHADER_NODE_CLASS(RGBCurvesNode)
415         float4 curves[RAMP_TABLE_SIZE];
416 };
417
418 class RGBRampNode : public ShaderNode {
419 public:
420         SHADER_NODE_CLASS(RGBRampNode)
421         float4 ramp[RAMP_TABLE_SIZE];
422 };
423
424 CCL_NAMESPACE_END
425
426 #endif /* __NODES_H__ */
427