Cycles: add location/rotate/scale and XYZ mapping options for all texture nodes,
[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 NoiseTextureNode : public TextureNode {
101 public:
102         SHADER_NODE_CLASS(NoiseTextureNode)
103 };
104
105 class BlendTextureNode : public TextureNode {
106 public:
107         SHADER_NODE_CLASS(BlendTextureNode)
108
109         ustring progression;
110         ustring axis;
111
112         static ShaderEnum progression_enum;
113         static ShaderEnum axis_enum;
114 };
115
116 class CloudsTextureNode : public TextureNode {
117 public:
118         SHADER_NODE_CLASS(CloudsTextureNode)
119
120         bool hard;
121         int depth;
122         ustring basis;
123
124         static ShaderEnum basis_enum;
125 };
126
127 class VoronoiTextureNode : public TextureNode {
128 public:
129         SHADER_NODE_CLASS(VoronoiTextureNode)
130
131         ustring distance_metric;
132         ustring coloring;
133
134         static ShaderEnum distance_metric_enum;
135         static ShaderEnum coloring_enum;
136 };
137
138 class MusgraveTextureNode : public TextureNode {
139 public:
140         SHADER_NODE_CLASS(MusgraveTextureNode)
141
142         ustring type;
143         ustring basis;
144
145         static ShaderEnum type_enum;
146         static ShaderEnum basis_enum;
147 };
148
149 class MarbleTextureNode : public TextureNode {
150 public:
151         SHADER_NODE_CLASS(MarbleTextureNode)
152
153         ustring type;
154         ustring wave;
155         ustring basis;
156         bool hard;
157         int depth;
158
159         static ShaderEnum type_enum;
160         static ShaderEnum wave_enum;
161         static ShaderEnum basis_enum;
162 };
163
164 class MagicTextureNode : public TextureNode {
165 public:
166         SHADER_NODE_CLASS(MagicTextureNode)
167
168         int depth;
169 };
170
171 class StucciTextureNode : public TextureNode {
172 public:
173         SHADER_NODE_CLASS(StucciTextureNode)
174
175         ustring type;
176         ustring basis;
177         bool hard;
178
179         static ShaderEnum type_enum;
180         static ShaderEnum basis_enum;
181 };
182
183 class DistortedNoiseTextureNode : public TextureNode {
184 public:
185         SHADER_NODE_CLASS(DistortedNoiseTextureNode)
186
187         ustring basis;
188         ustring distortion_basis;
189         static ShaderEnum basis_enum;
190 };
191
192 class WoodTextureNode : public TextureNode {
193 public:
194         SHADER_NODE_CLASS(WoodTextureNode)
195
196         ustring type;
197         ustring wave;
198         ustring basis;
199         bool hard;
200
201         static ShaderEnum type_enum;
202         static ShaderEnum wave_enum;
203         static ShaderEnum basis_enum;
204 };
205
206 class MappingNode : public ShaderNode {
207 public:
208         SHADER_NODE_CLASS(MappingNode)
209
210         TextureMapping tex_mapping;
211 };
212
213 class ConvertNode : public ShaderNode {
214 public:
215         ConvertNode(ShaderSocketType from, ShaderSocketType to);
216         SHADER_NODE_BASE_CLASS(ConvertNode)
217
218         ShaderSocketType from, to;
219 };
220
221 class BsdfNode : public ShaderNode {
222 public:
223         SHADER_NODE_CLASS(BsdfNode)
224
225         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
226
227         ClosureType closure;
228 };
229
230 class WardBsdfNode : public BsdfNode {
231 public:
232         SHADER_NODE_CLASS(WardBsdfNode)
233 };
234
235 class DiffuseBsdfNode : public BsdfNode {
236 public:
237         SHADER_NODE_CLASS(DiffuseBsdfNode)
238 };
239
240 class TranslucentBsdfNode : public BsdfNode {
241 public:
242         SHADER_NODE_CLASS(TranslucentBsdfNode)
243 };
244
245 class TransparentBsdfNode : public BsdfNode {
246 public:
247         SHADER_NODE_CLASS(TransparentBsdfNode)
248 };
249
250 class VelvetBsdfNode : public BsdfNode {
251 public:
252         SHADER_NODE_CLASS(VelvetBsdfNode)
253 };
254
255 class GlossyBsdfNode : public BsdfNode {
256 public:
257         SHADER_NODE_CLASS(GlossyBsdfNode)
258
259         ustring distribution;
260         static ShaderEnum distribution_enum;
261 };
262
263 class GlassBsdfNode : public BsdfNode {
264 public:
265         SHADER_NODE_CLASS(GlassBsdfNode)
266
267         ustring distribution;
268         static ShaderEnum distribution_enum;
269 };
270
271 class EmissionNode : public ShaderNode {
272 public:
273         SHADER_NODE_CLASS(EmissionNode)
274
275         bool total_power;
276 };
277
278 class BackgroundNode : public ShaderNode {
279 public:
280         SHADER_NODE_CLASS(BackgroundNode)
281 };
282
283 class HoldoutNode : public ShaderNode {
284 public:
285         SHADER_NODE_CLASS(HoldoutNode)
286 };
287
288 class VolumeNode : public ShaderNode {
289 public:
290         SHADER_NODE_CLASS(VolumeNode)
291
292         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
293
294         ClosureType closure;
295 };
296
297 class TransparentVolumeNode : public VolumeNode {
298 public:
299         SHADER_NODE_CLASS(TransparentVolumeNode)
300 };
301
302 class IsotropicVolumeNode : public VolumeNode {
303 public:
304         SHADER_NODE_CLASS(IsotropicVolumeNode)
305 };
306
307 class GeometryNode : public ShaderNode {
308 public:
309         SHADER_NODE_CLASS(GeometryNode)
310 };
311
312 class TextureCoordinateNode : public ShaderNode {
313 public:
314         SHADER_NODE_CLASS(TextureCoordinateNode)
315         void attributes(AttributeRequestSet *attributes);
316 };
317
318 class LightPathNode : public ShaderNode {
319 public:
320         SHADER_NODE_CLASS(LightPathNode)
321 };
322
323 class ValueNode : public ShaderNode {
324 public:
325         SHADER_NODE_CLASS(ValueNode)
326
327         float value;
328 };
329
330 class ColorNode : public ShaderNode {
331 public:
332         SHADER_NODE_CLASS(ColorNode)
333
334         float3 value;
335 };
336
337 class AddClosureNode : public ShaderNode {
338 public:
339         SHADER_NODE_CLASS(AddClosureNode)
340 };
341
342 class MixClosureNode : public ShaderNode {
343 public:
344         SHADER_NODE_CLASS(MixClosureNode)
345 };
346
347 class MixNode : public ShaderNode {
348 public:
349         SHADER_NODE_CLASS(MixNode)
350
351         ustring type;
352         static ShaderEnum type_enum;
353 };
354
355 class AttributeNode : public ShaderNode {
356 public:
357         SHADER_NODE_CLASS(AttributeNode)
358         void attributes(AttributeRequestSet *attributes);
359
360         ustring attribute;
361 };
362
363 class FresnelNode : public ShaderNode {
364 public:
365         SHADER_NODE_CLASS(FresnelNode)
366 };
367
368 class BlendWeightNode : public ShaderNode {
369 public:
370         SHADER_NODE_CLASS(BlendWeightNode)
371 };
372
373 class MathNode : public ShaderNode {
374 public:
375         SHADER_NODE_CLASS(MathNode)
376
377         ustring type;
378         static ShaderEnum type_enum;
379 };
380
381 class VectorMathNode : public ShaderNode {
382 public:
383         SHADER_NODE_CLASS(VectorMathNode)
384
385         ustring type;
386         static ShaderEnum type_enum;
387 };
388
389 class BumpNode : public ShaderNode {
390 public:
391         SHADER_NODE_CLASS(BumpNode)
392 };
393
394 CCL_NAMESPACE_END
395
396 #endif /* __NODES_H__ */
397