intern/cycles/render/nodes.h

   1 /*
   2  * Copyright 2011-2013 Blender Foundation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License
  15  */
  16
  17 #ifndef __NODES_H__
  18 #define __NODES_H__
  19
  20 #include "graph.h"
  21
  22 #include "util_string.h"
  23
  24 CCL_NAMESPACE_BEGIN
  25
  26 class ImageManager;
  27 class Shader;
  28
  29 /* Texture Mapping */
  30
  31 class TextureMapping {
  32 public:
  33         TextureMapping();
  34         Transform compute_transform();
  35         bool skip();
  36         void compile(SVMCompiler& compiler, int offset_in, int offset_out);
  37         void compile(OSLCompiler &compiler);
  38
  39         float3 translation;
  40         float3 rotation;
  41         float3 scale;
  42
  43         float3 min, max;
  44         bool use_minmax;
  45
  46         enum Type { POINT = 0, TEXTURE = 1, VECTOR = 2, NORMAL = 3 };
  47         Type type;
  48
  49         enum Mapping { NONE = 0, X = 1, Y = 2, Z = 3 };
  50         Mapping x_mapping, y_mapping, z_mapping;
  51
  52         enum Projection { FLAT, CUBE, TUBE, SPHERE };
  53         Projection projection;
  54 };
  55
  56 /* Nodes */
  57
  58 class TextureNode : public ShaderNode {
  59 public:
  60         TextureNode(const char *name_) : ShaderNode(name_) {}
  61         TextureMapping tex_mapping;
  62 };
  63
  64 class ImageTextureNode : public TextureNode {
  65 public:
  66         SHADER_NODE_NO_CLONE_CLASS(ImageTextureNode)
  67         ~ImageTextureNode();
  68         ShaderNode *clone() const;
  69         void attributes(Shader *shader, AttributeRequestSet *attributes);
  70
  71         ImageManager *image_manager;
  72         int slot;
  73         int is_float;
  74         bool is_linear;
  75         string filename;
  76         void *builtin_data;
  77         ustring color_space;
  78         ustring projection;
  79         InterpolationType interpolation;
  80         float projection_blend;
  81         bool animated;
  82
  83         static ShaderEnum color_space_enum;
  84         static ShaderEnum projection_enum;
  85 };
  86
  87 class EnvironmentTextureNode : public TextureNode {
  88 public:
  89         SHADER_NODE_NO_CLONE_CLASS(EnvironmentTextureNode)
  90         ~EnvironmentTextureNode();
  91         ShaderNode *clone() const;
  92         void attributes(Shader *shader, AttributeRequestSet *attributes);
  93
  94         ImageManager *image_manager;
  95         int slot;
  96         int is_float;
  97         bool is_linear;
  98         string filename;
  99         void *builtin_data;
 100         ustring color_space;
 101         ustring projection;
 102         bool animated;
 103
 104         static ShaderEnum color_space_enum;
 105         static ShaderEnum projection_enum;
 106 };
 107
 108 class SkyTextureNode : public TextureNode {
 109 public:
 110         SHADER_NODE_CLASS(SkyTextureNode)
 111
 112         float3 sun_direction;
 113         float turbidity;
 114         float ground_albedo;
 115
 116         ustring type;
 117         static ShaderEnum type_enum;
 118 };
 119
 120 class OutputNode : public ShaderNode {
 121 public:
 122         SHADER_NODE_CLASS(OutputNode)
 123 };
 124
 125 class GradientTextureNode : public TextureNode {
 126 public:
 127         SHADER_NODE_CLASS(GradientTextureNode)
 128
 129         ustring type;
 130         static ShaderEnum type_enum;
 131 };
 132
 133 class NoiseTextureNode : public TextureNode {
 134 public:
 135         SHADER_NODE_CLASS(NoiseTextureNode)
 136 };
 137
 138 class VoronoiTextureNode : public TextureNode {
 139 public:
 140         SHADER_NODE_CLASS(VoronoiTextureNode)
 141
 142         ustring coloring;
 143
 144         static ShaderEnum coloring_enum;
 145 };
 146
 147 class MusgraveTextureNode : public TextureNode {
 148 public:
 149         SHADER_NODE_CLASS(MusgraveTextureNode)
 150
 151         ustring type;
 152
 153         static ShaderEnum type_enum;
 154 };
 155
 156 class WaveTextureNode : public TextureNode {
 157 public:
 158         SHADER_NODE_CLASS(WaveTextureNode)
 159
 160         ustring type;
 161         static ShaderEnum type_enum;
 162 };
 163
 164 class MagicTextureNode : public TextureNode {
 165 public:
 166         SHADER_NODE_CLASS(MagicTextureNode)
 167
 168         int depth;
 169 };
 170
 171 class CheckerTextureNode : public TextureNode {
 172 public:
 173         SHADER_NODE_CLASS(CheckerTextureNode)
 174 };
 175
 176 class BrickTextureNode : public TextureNode {
 177 public:
 178         SHADER_NODE_CLASS(BrickTextureNode)
 179
 180         float offset, squash;
 181         int offset_frequency, squash_frequency;
 182 };
 183
 184 class MappingNode : public ShaderNode {
 185 public:
 186         SHADER_NODE_CLASS(MappingNode)
 187
 188         TextureMapping tex_mapping;
 189 };
 190
 191 class ConvertNode : public ShaderNode {
 192 public:
 193         ConvertNode(ShaderSocketType from, ShaderSocketType to, bool autoconvert = false);
 194         SHADER_NODE_BASE_CLASS(ConvertNode)
 195
 196         ShaderSocketType from, to;
 197 };
 198
 199 class ProxyNode : public ShaderNode {
 200 public:
 201         ProxyNode(ShaderSocketType type);
 202         SHADER_NODE_BASE_CLASS(ProxyNode)
 203
 204         ShaderSocketType type;
 205 };
 206
 207 class BsdfNode : public ShaderNode {
 208 public:
 209         BsdfNode(bool scattering = false);
 210         SHADER_NODE_BASE_CLASS(BsdfNode);
 211
 212         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2, ShaderInput *param3 = NULL, ShaderInput *param4 = NULL);
 213
 214         ClosureType closure;
 215         bool scattering;
 216 };
 217
 218 class WardBsdfNode : public BsdfNode {
 219 public:
 220         SHADER_NODE_CLASS(WardBsdfNode)
 221         void attributes(Shader *shader, AttributeRequestSet *attributes);
 222 };
 223
 224 class DiffuseBsdfNode : public BsdfNode {
 225 public:
 226         SHADER_NODE_CLASS(DiffuseBsdfNode)
 227 };
 228
 229 class TranslucentBsdfNode : public BsdfNode {
 230 public:
 231         SHADER_NODE_CLASS(TranslucentBsdfNode)
 232 };
 233
 234 class TransparentBsdfNode : public BsdfNode {
 235 public:
 236         SHADER_NODE_CLASS(TransparentBsdfNode)
 237
 238         bool has_surface_transparent() { return true; }
 239 };
 240
 241 class VelvetBsdfNode : public BsdfNode {
 242 public:
 243         SHADER_NODE_CLASS(VelvetBsdfNode)
 244 };
 245
 246 class GlossyBsdfNode : public BsdfNode {
 247 public:
 248         SHADER_NODE_CLASS(GlossyBsdfNode)
 249
 250         ustring distribution;
 251         static ShaderEnum distribution_enum;
 252 };
 253
 254 class GlassBsdfNode : public BsdfNode {
 255 public:
 256         SHADER_NODE_CLASS(GlassBsdfNode)
 257
 258         ustring distribution;
 259         static ShaderEnum distribution_enum;
 260 };
 261
 262 class RefractionBsdfNode : public BsdfNode {
 263 public:
 264         SHADER_NODE_CLASS(RefractionBsdfNode)
 265
 266         ustring distribution;
 267         static ShaderEnum distribution_enum;
 268 };
 269
 270 class ToonBsdfNode : public BsdfNode {
 271 public:
 272         SHADER_NODE_CLASS(ToonBsdfNode)
 273
 274         ustring component;
 275         static ShaderEnum component_enum;
 276 };
 277
 278 class SubsurfaceScatteringNode : public BsdfNode {
 279 public:
 280         SHADER_NODE_CLASS(SubsurfaceScatteringNode)
 281         bool has_surface_bssrdf() { return true; }
 282         bool has_bssrdf_bump();
 283
 284         static ShaderEnum falloff_enum;
 285 };
 286
 287 class EmissionNode : public ShaderNode {
 288 public:
 289         SHADER_NODE_CLASS(EmissionNode)
 290
 291         bool has_surface_emission() { return true; }
 292
 293         bool total_power;
 294 };
 295
 296 class BackgroundNode : public ShaderNode {
 297 public:
 298         SHADER_NODE_CLASS(BackgroundNode)
 299 };
 300
 301 class HoldoutNode : public ShaderNode {
 302 public:
 303         SHADER_NODE_CLASS(HoldoutNode)
 304 };
 305
 306 class AmbientOcclusionNode : public ShaderNode {
 307 public:
 308         SHADER_NODE_CLASS(AmbientOcclusionNode)
 309 };
 310
 311 class VolumeNode : public ShaderNode {
 312 public:
 313         SHADER_NODE_CLASS(VolumeNode)
 314
 315         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
 316
 317         ClosureType closure;
 318 };
 319
 320 class AbsorptionVolumeNode : public VolumeNode {
 321 public:
 322         SHADER_NODE_CLASS(AbsorptionVolumeNode)
 323 };
 324
 325 class ScatterVolumeNode : public VolumeNode {
 326 public:
 327         SHADER_NODE_CLASS(ScatterVolumeNode)
 328 };
 329
 330 class HairBsdfNode : public BsdfNode {
 331 public:
 332         SHADER_NODE_CLASS(HairBsdfNode)
 333
 334         ustring component;
 335         static ShaderEnum component_enum;
 336
 337 };
 338
 339 class GeometryNode : public ShaderNode {
 340 public:
 341         SHADER_NODE_CLASS(GeometryNode)
 342         void attributes(Shader *shader, AttributeRequestSet *attributes);
 343 };
 344
 345 class TextureCoordinateNode : public ShaderNode {
 346 public:
 347         SHADER_NODE_CLASS(TextureCoordinateNode)
 348         void attributes(Shader *shader, AttributeRequestSet *attributes);
 349
 350         bool from_dupli;
 351 };
 352
 353 class UVMapNode : public ShaderNode {
 354 public:
 355         SHADER_NODE_CLASS(UVMapNode)
 356         void attributes(Shader *shader, AttributeRequestSet *attributes);
 357
 358         ustring attribute;
 359         bool from_dupli;
 360 };
 361
 362 class LightPathNode : public ShaderNode {
 363 public:
 364         SHADER_NODE_CLASS(LightPathNode)
 365 };
 366
 367 class LightFalloffNode : public ShaderNode {
 368 public:
 369         SHADER_NODE_CLASS(LightFalloffNode)
 370 };
 371
 372 class ObjectInfoNode : public ShaderNode {
 373 public:
 374         SHADER_NODE_CLASS(ObjectInfoNode)
 375 };
 376
 377 class ParticleInfoNode : public ShaderNode {
 378 public:
 379         SHADER_NODE_CLASS(ParticleInfoNode)
 380         void attributes(Shader *shader, AttributeRequestSet *attributes);
 381 };
 382
 383 class HairInfoNode : public ShaderNode {
 384 public:
 385         SHADER_NODE_CLASS(HairInfoNode)
 386
 387         void attributes(Shader *shader, AttributeRequestSet *attributes);
 388 };
 389
 390 class ValueNode : public ShaderNode {
 391 public:
 392         SHADER_NODE_CLASS(ValueNode)
 393
 394         float value;
 395 };
 396
 397 class ColorNode : public ShaderNode {
 398 public:
 399         SHADER_NODE_CLASS(ColorNode)
 400
 401         float3 value;
 402 };
 403
 404 class AddClosureNode : public ShaderNode {
 405 public:
 406         SHADER_NODE_CLASS(AddClosureNode)
 407 };
 408
 409 class MixClosureNode : public ShaderNode {
 410 public:
 411         SHADER_NODE_CLASS(MixClosureNode)
 412 };
 413
 414 class MixClosureWeightNode : public ShaderNode {
 415 public:
 416         SHADER_NODE_CLASS(MixClosureWeightNode);
 417 };
 418
 419 class InvertNode : public ShaderNode {
 420 public:
 421         SHADER_NODE_CLASS(InvertNode)
 422 };
 423
 424 class MixNode : public ShaderNode {
 425 public:
 426         SHADER_NODE_CLASS(MixNode)
 427
 428         bool use_clamp;
 429
 430         ustring type;
 431         static ShaderEnum type_enum;
 432 };
 433
 434 class CombineRGBNode : public ShaderNode {
 435 public:
 436         SHADER_NODE_CLASS(CombineRGBNode)
 437 };
 438
 439 class CombineHSVNode : public ShaderNode {
 440 public:
 441         SHADER_NODE_CLASS(CombineHSVNode)
 442 };
 443
 444 class GammaNode : public ShaderNode {
 445 public:
 446         SHADER_NODE_CLASS(GammaNode)
 447 };
 448
 449 class BrightContrastNode : public ShaderNode {
 450 public:
 451         SHADER_NODE_CLASS(BrightContrastNode)
 452 };
 453
 454 class SeparateRGBNode : public ShaderNode {
 455 public:
 456         SHADER_NODE_CLASS(SeparateRGBNode)
 457 };
 458
 459 class SeparateHSVNode : public ShaderNode {
 460 public:
 461         SHADER_NODE_CLASS(SeparateHSVNode)
 462 };
 463
 464 class HSVNode : public ShaderNode {
 465 public:
 466         SHADER_NODE_CLASS(HSVNode)
 467 };
 468
 469 class AttributeNode : public ShaderNode {
 470 public:
 471         SHADER_NODE_CLASS(AttributeNode)
 472         void attributes(Shader *shader, AttributeRequestSet *attributes);
 473
 474         ustring attribute;
 475 };
 476
 477 class CameraNode : public ShaderNode {
 478 public:
 479         SHADER_NODE_CLASS(CameraNode)
 480 };
 481
 482 class FresnelNode : public ShaderNode {
 483 public:
 484         SHADER_NODE_CLASS(FresnelNode)
 485 };
 486
 487 class LayerWeightNode : public ShaderNode {
 488 public:
 489         SHADER_NODE_CLASS(LayerWeightNode)
 490 };
 491
 492 class WireframeNode : public ShaderNode {
 493 public:
 494         SHADER_NODE_CLASS(WireframeNode)
 495
 496         bool use_pixel_size;
 497 };
 498
 499 class WavelengthNode : public ShaderNode {
 500 public:
 501         SHADER_NODE_CLASS(WavelengthNode)
 502 };
 503
 504 class BlackbodyNode : public ShaderNode {
 505 public:
 506         SHADER_NODE_CLASS(BlackbodyNode)
 507
 508         bool has_converter_blackbody() { return true; }
 509 };
 510
 511 class MathNode : public ShaderNode {
 512 public:
 513         SHADER_NODE_CLASS(MathNode)
 514
 515         bool use_clamp;
 516
 517         ustring type;
 518         static ShaderEnum type_enum;
 519 };
 520
 521 class NormalNode : public ShaderNode {
 522 public:
 523         SHADER_NODE_CLASS(NormalNode)
 524
 525         float3 direction;
 526 };
 527
 528 class VectorMathNode : public ShaderNode {
 529 public:
 530         SHADER_NODE_CLASS(VectorMathNode)
 531
 532         ustring type;
 533         static ShaderEnum type_enum;
 534 };
 535
 536 class VectorTransformNode : public ShaderNode {
 537 public:
 538         SHADER_NODE_CLASS(VectorTransformNode)
 539
 540         ustring type;
 541         ustring convert_from;
 542         ustring convert_to;
 543
 544         static ShaderEnum type_enum;
 545         static ShaderEnum convert_space_enum;
 546 };
 547
 548 class BumpNode : public ShaderNode {
 549 public:
 550         SHADER_NODE_CLASS(BumpNode)
 551         bool invert;
 552 };
 553
 554 class RGBCurvesNode : public ShaderNode {
 555 public:
 556         SHADER_NODE_CLASS(RGBCurvesNode)
 557         float4 curves[RAMP_TABLE_SIZE];
 558 };
 559
 560 class VectorCurvesNode : public ShaderNode {
 561 public:
 562         SHADER_NODE_CLASS(VectorCurvesNode)
 563         float4 curves[RAMP_TABLE_SIZE];
 564 };
 565
 566 class RGBRampNode : public ShaderNode {
 567 public:
 568         SHADER_NODE_CLASS(RGBRampNode)
 569         float4 ramp[RAMP_TABLE_SIZE];
 570         bool interpolate;
 571 };
 572
 573 class SetNormalNode : public ShaderNode {
 574 public:
 575         SHADER_NODE_CLASS(SetNormalNode)
 576 };
 577
 578 class OSLScriptNode : public ShaderNode {
 579 public:
 580         SHADER_NODE_CLASS(OSLScriptNode)
 581         string filepath;
 582         string bytecode_hash;
 583
 584         /* ShaderInput/ShaderOutput only stores a shallow string copy (const char *)!
 585          * The actual socket names have to be stored externally to avoid memory errors. */
 586         vector<ustring> input_names;
 587         vector<ustring> output_names;
 588 };
 589
 590 class NormalMapNode : public ShaderNode {
 591 public:
 592         SHADER_NODE_CLASS(NormalMapNode)
 593         void attributes(Shader *shader, AttributeRequestSet *attributes);
 594
 595         ustring space;
 596         static ShaderEnum space_enum;
 597
 598         ustring attribute;
 599 };
 600
 601 class TangentNode : public ShaderNode {
 602 public:
 603         SHADER_NODE_CLASS(TangentNode)
 604         void attributes(Shader *shader, AttributeRequestSet *attributes);
 605
 606         ustring direction_type;
 607         static ShaderEnum direction_type_enum;
 608
 609         ustring axis;
 610         static ShaderEnum axis_enum;
 611
 612         ustring attribute;
 613 };
 614
 615 CCL_NAMESPACE_END
 616
 617 #endif /* __NODES_H__ */
 618