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