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 MappingNode : public ShaderNode {
 147 public:
 148         SHADER_NODE_CLASS(MappingNode)
 149
 150         TextureMapping tex_mapping;
 151 };
 152
 153 class ConvertNode : public ShaderNode {
 154 public:
 155         ConvertNode(ShaderSocketType from, ShaderSocketType to);
 156         SHADER_NODE_BASE_CLASS(ConvertNode)
 157
 158         ShaderSocketType from, to;
 159 };
 160
 161 class BsdfNode : public ShaderNode {
 162 public:
 163         SHADER_NODE_CLASS(BsdfNode)
 164
 165         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
 166
 167         ClosureType closure;
 168 };
 169
 170 class WardBsdfNode : public BsdfNode {
 171 public:
 172         SHADER_NODE_CLASS(WardBsdfNode)
 173 };
 174
 175 class DiffuseBsdfNode : public BsdfNode {
 176 public:
 177         SHADER_NODE_CLASS(DiffuseBsdfNode)
 178 };
 179
 180 class TranslucentBsdfNode : public BsdfNode {
 181 public:
 182         SHADER_NODE_CLASS(TranslucentBsdfNode)
 183 };
 184
 185 class TransparentBsdfNode : public BsdfNode {
 186 public:
 187         SHADER_NODE_CLASS(TransparentBsdfNode)
 188 };
 189
 190 class VelvetBsdfNode : public BsdfNode {
 191 public:
 192         SHADER_NODE_CLASS(VelvetBsdfNode)
 193 };
 194
 195 class GlossyBsdfNode : public BsdfNode {
 196 public:
 197         SHADER_NODE_CLASS(GlossyBsdfNode)
 198
 199         ustring distribution;
 200         static ShaderEnum distribution_enum;
 201 };
 202
 203 class GlassBsdfNode : public BsdfNode {
 204 public:
 205         SHADER_NODE_CLASS(GlassBsdfNode)
 206
 207         ustring distribution;
 208         static ShaderEnum distribution_enum;
 209 };
 210
 211 class EmissionNode : public ShaderNode {
 212 public:
 213         SHADER_NODE_CLASS(EmissionNode)
 214
 215         bool total_power;
 216 };
 217
 218 class BackgroundNode : public ShaderNode {
 219 public:
 220         SHADER_NODE_CLASS(BackgroundNode)
 221 };
 222
 223 class HoldoutNode : public ShaderNode {
 224 public:
 225         SHADER_NODE_CLASS(HoldoutNode)
 226 };
 227
 228 class VolumeNode : public ShaderNode {
 229 public:
 230         SHADER_NODE_CLASS(VolumeNode)
 231
 232         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
 233
 234         ClosureType closure;
 235 };
 236
 237 class TransparentVolumeNode : public VolumeNode {
 238 public:
 239         SHADER_NODE_CLASS(TransparentVolumeNode)
 240 };
 241
 242 class IsotropicVolumeNode : public VolumeNode {
 243 public:
 244         SHADER_NODE_CLASS(IsotropicVolumeNode)
 245 };
 246
 247 class GeometryNode : public ShaderNode {
 248 public:
 249         SHADER_NODE_CLASS(GeometryNode)
 250 };
 251
 252 class TextureCoordinateNode : public ShaderNode {
 253 public:
 254         SHADER_NODE_CLASS(TextureCoordinateNode)
 255         void attributes(AttributeRequestSet *attributes);
 256 };
 257
 258 class LightPathNode : public ShaderNode {
 259 public:
 260         SHADER_NODE_CLASS(LightPathNode)
 261 };
 262
 263 class ValueNode : public ShaderNode {
 264 public:
 265         SHADER_NODE_CLASS(ValueNode)
 266
 267         float value;
 268 };
 269
 270 class ColorNode : public ShaderNode {
 271 public:
 272         SHADER_NODE_CLASS(ColorNode)
 273
 274         float3 value;
 275 };
 276
 277 class AddClosureNode : public ShaderNode {
 278 public:
 279         SHADER_NODE_CLASS(AddClosureNode)
 280 };
 281
 282 class MixClosureNode : public ShaderNode {
 283 public:
 284         SHADER_NODE_CLASS(MixClosureNode)
 285 };
 286
 287 class InvertNode : public ShaderNode {
 288 public:
 289         SHADER_NODE_CLASS(InvertNode)
 290 };
 291
 292 class MixNode : public ShaderNode {
 293 public:
 294         SHADER_NODE_CLASS(MixNode)
 295
 296         ustring type;
 297         static ShaderEnum type_enum;
 298 };
 299
 300 class CombineRGBNode : public ShaderNode {
 301 public:
 302         SHADER_NODE_CLASS(CombineRGBNode)
 303 };
 304
 305 class SeparateRGBNode : public ShaderNode {
 306 public:
 307         SHADER_NODE_CLASS(SeparateRGBNode)
 308 };
 309
 310 class HSVNode : public ShaderNode {
 311 public:
 312         SHADER_NODE_CLASS(HSVNode)
 313 };
 314
 315 class AttributeNode : public ShaderNode {
 316 public:
 317         SHADER_NODE_CLASS(AttributeNode)
 318         void attributes(AttributeRequestSet *attributes);
 319
 320         ustring attribute;
 321 };
 322
 323 class CameraNode : public ShaderNode {
 324 public:
 325         SHADER_NODE_CLASS(CameraNode)
 326 };
 327
 328 class FresnelNode : public ShaderNode {
 329 public:
 330         SHADER_NODE_CLASS(FresnelNode)
 331 };
 332
 333 class LayerWeightNode : public ShaderNode {
 334 public:
 335         SHADER_NODE_CLASS(LayerWeightNode)
 336 };
 337
 338 class MathNode : public ShaderNode {
 339 public:
 340         SHADER_NODE_CLASS(MathNode)
 341
 342         ustring type;
 343         static ShaderEnum type_enum;
 344 };
 345
 346 class VectorMathNode : public ShaderNode {
 347 public:
 348         SHADER_NODE_CLASS(VectorMathNode)
 349
 350         ustring type;
 351         static ShaderEnum type_enum;
 352 };
 353
 354 class BumpNode : public ShaderNode {
 355 public:
 356         SHADER_NODE_CLASS(BumpNode)
 357 };
 358
 359 CCL_NAMESPACE_END
 360
 361 #endif /* __NODES_H__ */
 362