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 "render/graph.h"
  21 #include "graph/node.h"
  22
  23 #include "util/util_string.h"
  24
  25 CCL_NAMESPACE_BEGIN
  26
  27 class ImageManager;
  28 class Scene;
  29 class Shader;
  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         int compile(SVMCompiler& compiler, ShaderInput *vector_in);
  40         void compile(OSLCompiler &compiler);
  41
  42         int compile_begin(SVMCompiler& compiler, ShaderInput *vector_in);
  43         void compile_end(SVMCompiler& compiler, ShaderInput *vector_in, int vector_offset);
  44
  45         float3 translation;
  46         float3 rotation;
  47         float3 scale;
  48
  49         float3 min, max;
  50         bool use_minmax;
  51
  52         enum Type { POINT = 0, TEXTURE = 1, VECTOR = 2, NORMAL = 3 };
  53         Type type;
  54
  55         enum Mapping { NONE = 0, X = 1, Y = 2, Z = 3 };
  56         Mapping x_mapping, y_mapping, z_mapping;
  57
  58         enum Projection { FLAT, CUBE, TUBE, SPHERE };
  59         Projection projection;
  60 };
  61
  62 /* Nodes */
  63
  64 class TextureNode : public ShaderNode {
  65 public:
  66         explicit TextureNode(const NodeType *node_type) : ShaderNode(node_type) {}
  67         TextureMapping tex_mapping;
  68 };
  69
  70 /* Any node which uses image manager's slot should be a subclass of this one. */
  71 class ImageSlotTextureNode : public TextureNode {
  72 public:
  73         explicit ImageSlotTextureNode(const NodeType *node_type) : TextureNode(node_type) {
  74                 special_type = SHADER_SPECIAL_TYPE_IMAGE_SLOT;
  75         }
  76         int slot;
  77 };
  78
  79 class ImageTextureNode : public ImageSlotTextureNode {
  80 public:
  81         SHADER_NODE_NO_CLONE_CLASS(ImageTextureNode)
  82         ~ImageTextureNode();
  83         ShaderNode *clone() const;
  84         void attributes(Shader *shader, AttributeRequestSet *attributes);
  85
  86         ImageManager *image_manager;
  87         int is_float;
  88         bool is_linear;
  89         bool use_alpha;
  90         ustring filename;
  91         void *builtin_data;
  92         NodeImageColorSpace color_space;
  93         NodeImageProjection projection;
  94         InterpolationType interpolation;
  95         ExtensionType extension;
  96         float projection_blend;
  97         bool animated;
  98         float3 vector;
  99
 100         virtual bool equals(const ShaderNode& other)
 101         {
 102                 const ImageTextureNode& image_node = (const ImageTextureNode&)other;
 103                 return ImageSlotTextureNode::equals(other) &&
 104                        builtin_data == image_node.builtin_data &&
 105                        animated == image_node.animated;
 106         }
 107 };
 108
 109 class EnvironmentTextureNode : public ImageSlotTextureNode {
 110 public:
 111         SHADER_NODE_NO_CLONE_CLASS(EnvironmentTextureNode)
 112         ~EnvironmentTextureNode();
 113         ShaderNode *clone() const;
 114         void attributes(Shader *shader, AttributeRequestSet *attributes);
 115         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
 116
 117         ImageManager *image_manager;
 118         int is_float;
 119         bool is_linear;
 120         bool use_alpha;
 121         ustring filename;
 122         void *builtin_data;
 123         NodeImageColorSpace color_space;
 124         NodeEnvironmentProjection projection;
 125         InterpolationType interpolation;
 126         bool animated;
 127         float3 vector;
 128
 129         virtual bool equals(const ShaderNode& other)
 130         {
 131                 const EnvironmentTextureNode& env_node = (const EnvironmentTextureNode&)other;
 132                 return ImageSlotTextureNode::equals(other) &&
 133                        builtin_data == env_node.builtin_data &&
 134                        animated == env_node.animated;
 135         }
 136 };
 137
 138 class SkyTextureNode : public TextureNode {
 139 public:
 140         SHADER_NODE_CLASS(SkyTextureNode)
 141
 142         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
 143
 144         NodeSkyType type;
 145         float3 sun_direction;
 146         float turbidity;
 147         float ground_albedo;
 148         float3 vector;
 149 };
 150
 151 class OutputNode : public ShaderNode {
 152 public:
 153         SHADER_NODE_CLASS(OutputNode)
 154
 155         void *surface;
 156         void *volume;
 157         float displacement;
 158         float3 normal;
 159
 160         /* Don't allow output node de-duplication. */
 161         virtual bool equals(const ShaderNode& /*other*/) { return false; }
 162 };
 163
 164 class GradientTextureNode : public TextureNode {
 165 public:
 166         SHADER_NODE_CLASS(GradientTextureNode)
 167
 168         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
 169
 170         NodeGradientType type;
 171         float3 vector;
 172 };
 173
 174 class NoiseTextureNode : public TextureNode {
 175 public:
 176         SHADER_NODE_CLASS(NoiseTextureNode)
 177
 178         float scale, detail, distortion;
 179         float3 vector;
 180 };
 181
 182 class VoronoiTextureNode : public TextureNode {
 183 public:
 184         SHADER_NODE_CLASS(VoronoiTextureNode)
 185
 186         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
 187
 188         NodeVoronoiColoring coloring;
 189         float scale;
 190         float3 vector;
 191 };
 192
 193 class MusgraveTextureNode : public TextureNode {
 194 public:
 195         SHADER_NODE_CLASS(MusgraveTextureNode)
 196
 197         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
 198
 199         NodeMusgraveType type;
 200         float scale, detail, dimension, lacunarity, offset, gain;
 201         float3 vector;
 202 };
 203
 204 class WaveTextureNode : public TextureNode {
 205 public:
 206         SHADER_NODE_CLASS(WaveTextureNode)
 207
 208         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
 209
 210         NodeWaveType type;
 211         NodeWaveProfile profile;
 212
 213         float scale, distortion, detail, detail_scale;
 214         float3 vector;
 215 };
 216
 217 class MagicTextureNode : public TextureNode {
 218 public:
 219         SHADER_NODE_CLASS(MagicTextureNode)
 220
 221         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
 222
 223         int depth;
 224         float3 vector;
 225         float scale, distortion;
 226 };
 227
 228 class CheckerTextureNode : public TextureNode {
 229 public:
 230         SHADER_NODE_CLASS(CheckerTextureNode)
 231
 232         float3 vector, color1, color2;
 233         float scale;
 234
 235         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
 236 };
 237
 238 class BrickTextureNode : public TextureNode {
 239 public:
 240         SHADER_NODE_CLASS(BrickTextureNode)
 241
 242         float offset, squash;
 243         int offset_frequency, squash_frequency;
 244
 245         float3 color1, color2, mortar;
 246         float scale, mortar_size, mortar_smooth, bias, brick_width, row_height;
 247         float3 vector;
 248
 249         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
 250 };
 251
 252 class PointDensityTextureNode : public ShaderNode {
 253 public:
 254         SHADER_NODE_NO_CLONE_CLASS(PointDensityTextureNode)
 255         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 256
 257         ~PointDensityTextureNode();
 258         ShaderNode *clone() const;
 259         void attributes(Shader *shader, AttributeRequestSet *attributes);
 260
 261         bool has_spatial_varying() { return true; }
 262         bool has_object_dependency() { return true; }
 263
 264         ustring filename;
 265         NodeTexVoxelSpace space;
 266         InterpolationType interpolation;
 267         Transform tfm;
 268         float3 vector;
 269
 270         ImageManager *image_manager;
 271         int slot;
 272         void *builtin_data;
 273
 274         virtual bool equals(const ShaderNode& other) {
 275                 const PointDensityTextureNode& point_dendity_node = (const PointDensityTextureNode&)other;
 276                 return ShaderNode::equals(other) &&
 277                        builtin_data == point_dendity_node.builtin_data;
 278         }
 279 };
 280
 281 class MappingNode : public ShaderNode {
 282 public:
 283         SHADER_NODE_CLASS(MappingNode)
 284         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
 285
 286         float3 vector;
 287         TextureMapping tex_mapping;
 288 };
 289
 290 class RGBToBWNode : public ShaderNode {
 291 public:
 292         SHADER_NODE_CLASS(RGBToBWNode)
 293         void constant_fold(const ConstantFolder& folder);
 294
 295         float3 color;
 296 };
 297
 298 class ConvertNode : public ShaderNode {
 299 public:
 300         ConvertNode(SocketType::Type from, SocketType::Type to, bool autoconvert = false);
 301         SHADER_NODE_BASE_CLASS(ConvertNode)
 302
 303         void constant_fold(const ConstantFolder& folder);
 304
 305         SocketType::Type from, to;
 306
 307         union {
 308                 float value_float;
 309                 int value_int;
 310                 float3 value_color;
 311                 float3 value_vector;
 312                 float3 value_point;
 313                 float3 value_normal;
 314         };
 315         ustring value_string;
 316
 317 private:
 318         static const int MAX_TYPE = 12;
 319         static bool register_types();
 320         static Node* create(const NodeType *type);
 321         static const NodeType *node_types[MAX_TYPE][MAX_TYPE];
 322         static bool initialized;
 323 };
 324
 325 class BsdfBaseNode : public ShaderNode {
 326 public:
 327         BsdfBaseNode(const NodeType *node_type);
 328
 329         bool has_spatial_varying() { return true; }
 330         virtual ClosureType get_closure_type() { return closure; }
 331         virtual bool has_bump();
 332
 333         virtual bool equals(const ShaderNode& /*other*/)
 334         {
 335                 /* TODO(sergey): With some care BSDF nodes can be de-duplicated. */
 336                 return false;
 337         }
 338
 339         ClosureType closure;
 340 };
 341
 342 class BsdfNode : public BsdfBaseNode {
 343 public:
 344         explicit BsdfNode(const NodeType *node_type);
 345         SHADER_NODE_BASE_CLASS(BsdfNode)
 346
 347         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2, ShaderInput *param3 = NULL, ShaderInput *param4 = NULL);
 348
 349         float3 color;
 350         float3 normal;
 351         float surface_mix_weight;
 352 };
 353
 354 class AnisotropicBsdfNode : public BsdfNode {
 355 public:
 356         SHADER_NODE_CLASS(AnisotropicBsdfNode)
 357
 358         float3 tangent;
 359         float roughness, anisotropy, rotation;
 360         ClosureType distribution;
 361
 362         ClosureType get_closure_type() { return distribution; }
 363         void attributes(Shader *shader, AttributeRequestSet *attributes);
 364 };
 365
 366 class DiffuseBsdfNode : public BsdfNode {
 367 public:
 368         SHADER_NODE_CLASS(DiffuseBsdfNode)
 369
 370         float roughness;
 371 };
 372
 373 /* Disney principled BRDF */
 374 class PrincipledBsdfNode : public BsdfBaseNode {
 375 public:
 376         SHADER_NODE_CLASS(PrincipledBsdfNode)
 377
 378         bool has_surface_bssrdf();
 379         bool has_bssrdf_bump();
 380         void compile(SVMCompiler& compiler, ShaderInput *metallic, ShaderInput *subsurface, ShaderInput *subsurface_radius,
 381                 ShaderInput *specular, ShaderInput *roughness, ShaderInput *specular_tint, ShaderInput *anisotropic,
 382                 ShaderInput *sheen, ShaderInput *sheen_tint, ShaderInput *clearcoat, ShaderInput *clearcoat_roughness,
 383                 ShaderInput *ior, ShaderInput *transmission, ShaderInput *anisotropic_rotation, ShaderInput *transmission_roughness);
 384
 385         float3 base_color;
 386         float3 subsurface_color, subsurface_radius;
 387         float metallic, subsurface, specular, roughness, specular_tint, anisotropic,
 388                 sheen, sheen_tint, clearcoat, clearcoat_roughness, ior, transmission,
 389                 anisotropic_rotation, transmission_roughness;
 390         float3 normal, clearcoat_normal, tangent;
 391         float surface_mix_weight;
 392         ClosureType distribution, distribution_orig;
 393
 394         bool has_integrator_dependency();
 395         void attributes(Shader *shader, AttributeRequestSet *attributes);
 396 };
 397
 398 class TranslucentBsdfNode : public BsdfNode {
 399 public:
 400         SHADER_NODE_CLASS(TranslucentBsdfNode)
 401 };
 402
 403 class TransparentBsdfNode : public BsdfNode {
 404 public:
 405         SHADER_NODE_CLASS(TransparentBsdfNode)
 406
 407         bool has_surface_transparent() { return true; }
 408 };
 409
 410 class VelvetBsdfNode : public BsdfNode {
 411 public:
 412         SHADER_NODE_CLASS(VelvetBsdfNode)
 413
 414         float sigma;
 415 };
 416
 417 class GlossyBsdfNode : public BsdfNode {
 418 public:
 419         SHADER_NODE_CLASS(GlossyBsdfNode)
 420
 421         void simplify_settings(Scene *scene);
 422         bool has_integrator_dependency();
 423         ClosureType get_closure_type() { return distribution; }
 424
 425         float roughness, roughness_orig;
 426         ClosureType distribution, distribution_orig;
 427 };
 428
 429 class GlassBsdfNode : public BsdfNode {
 430 public:
 431         SHADER_NODE_CLASS(GlassBsdfNode)
 432
 433         void simplify_settings(Scene *scene);
 434         bool has_integrator_dependency();
 435         ClosureType get_closure_type() { return distribution; }
 436
 437         float roughness, roughness_orig, IOR;
 438         ClosureType distribution, distribution_orig;
 439 };
 440
 441 class RefractionBsdfNode : public BsdfNode {
 442 public:
 443         SHADER_NODE_CLASS(RefractionBsdfNode)
 444
 445         void simplify_settings(Scene *scene);
 446         bool has_integrator_dependency();
 447         ClosureType get_closure_type() { return distribution; }
 448
 449         float roughness, roughness_orig, IOR;
 450         ClosureType distribution, distribution_orig;
 451 };
 452
 453 class ToonBsdfNode : public BsdfNode {
 454 public:
 455         SHADER_NODE_CLASS(ToonBsdfNode)
 456
 457         float smooth, size;
 458         ClosureType component;
 459 };
 460
 461 class SubsurfaceScatteringNode : public BsdfNode {
 462 public:
 463         SHADER_NODE_CLASS(SubsurfaceScatteringNode)
 464         bool has_surface_bssrdf() { return true; }
 465         bool has_bssrdf_bump();
 466         ClosureType get_closure_type() { return falloff; }
 467
 468         float scale;
 469         float3 radius;
 470         float sharpness;
 471         float texture_blur;
 472         ClosureType falloff;
 473 };
 474
 475 class EmissionNode : public ShaderNode {
 476 public:
 477         SHADER_NODE_CLASS(EmissionNode)
 478         void constant_fold(const ConstantFolder& folder);
 479
 480         bool has_surface_emission() { return true; }
 481         bool has_volume_support() { return true; }
 482
 483         float3 color;
 484         float strength;
 485         float surface_mix_weight;
 486 };
 487
 488 class BackgroundNode : public ShaderNode {
 489 public:
 490         SHADER_NODE_CLASS(BackgroundNode)
 491         void constant_fold(const ConstantFolder& folder);
 492
 493         float3 color;
 494         float strength;
 495         float surface_mix_weight;
 496 };
 497
 498 class HoldoutNode : public ShaderNode {
 499 public:
 500         SHADER_NODE_CLASS(HoldoutNode)
 501         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 502         virtual ClosureType get_closure_type() { return CLOSURE_HOLDOUT_ID; }
 503
 504         float surface_mix_weight;
 505         float volume_mix_weight;
 506 };
 507
 508 class AmbientOcclusionNode : public ShaderNode {
 509 public:
 510         SHADER_NODE_CLASS(AmbientOcclusionNode)
 511
 512         bool has_spatial_varying() { return true; }
 513         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 514         virtual ClosureType get_closure_type() { return CLOSURE_AMBIENT_OCCLUSION_ID; }
 515
 516         float3 normal_osl;
 517         float3 color;
 518         float surface_mix_weight;
 519 };
 520
 521 class VolumeNode : public ShaderNode {
 522 public:
 523         VolumeNode(const NodeType *node_type);
 524         SHADER_NODE_BASE_CLASS(VolumeNode)
 525
 526         void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
 527         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 528         virtual int get_feature() {
 529                 return ShaderNode::get_feature() | NODE_FEATURE_VOLUME;
 530         }
 531         virtual ClosureType get_closure_type() { return closure; }
 532         virtual bool has_volume_support() { return true; }
 533
 534         float3 color;
 535         float density;
 536         float volume_mix_weight;
 537         ClosureType closure;
 538
 539         virtual bool equals(const ShaderNode& /*other*/)
 540         {
 541                 /* TODO(sergey): With some care Volume nodes can be de-duplicated. */
 542                 return false;
 543         }
 544 };
 545
 546 class AbsorptionVolumeNode : public VolumeNode {
 547 public:
 548         SHADER_NODE_CLASS(AbsorptionVolumeNode)
 549 };
 550
 551 class ScatterVolumeNode : public VolumeNode {
 552 public:
 553         SHADER_NODE_CLASS(ScatterVolumeNode)
 554
 555         float anisotropy;
 556 };
 557
 558 class HairBsdfNode : public BsdfNode {
 559 public:
 560         SHADER_NODE_CLASS(HairBsdfNode)
 561         ClosureType get_closure_type() { return component; }
 562
 563         ClosureType component;
 564         float offset;
 565         float roughness_u;
 566         float roughness_v;
 567         float3 tangent;
 568 };
 569
 570 class GeometryNode : public ShaderNode {
 571 public:
 572         SHADER_NODE_CLASS(GeometryNode)
 573         void attributes(Shader *shader, AttributeRequestSet *attributes);
 574         bool has_spatial_varying() { return true; }
 575
 576         float3 normal_osl;
 577 };
 578
 579 class TextureCoordinateNode : public ShaderNode {
 580 public:
 581         SHADER_NODE_CLASS(TextureCoordinateNode)
 582         void attributes(Shader *shader, AttributeRequestSet *attributes);
 583         bool has_spatial_varying() { return true; }
 584         bool has_object_dependency() { return use_transform; }
 585
 586         float3 normal_osl;
 587         bool from_dupli;
 588         bool use_transform;
 589         Transform ob_tfm;
 590 };
 591
 592 class UVMapNode : public ShaderNode {
 593 public:
 594         SHADER_NODE_CLASS(UVMapNode)
 595         void attributes(Shader *shader, AttributeRequestSet *attributes);
 596         bool has_spatial_varying() { return true; }
 597         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 598
 599         ustring attribute;
 600         bool from_dupli;
 601 };
 602
 603 class LightPathNode : public ShaderNode {
 604 public:
 605         SHADER_NODE_CLASS(LightPathNode)
 606         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 607 };
 608
 609 class LightFalloffNode : public ShaderNode {
 610 public:
 611         SHADER_NODE_CLASS(LightFalloffNode)
 612         bool has_spatial_varying() { return true; }
 613         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
 614
 615         float strength;
 616         float smooth;
 617 };
 618
 619 class ObjectInfoNode : public ShaderNode {
 620 public:
 621         SHADER_NODE_CLASS(ObjectInfoNode)
 622         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 623 };
 624
 625 class ParticleInfoNode : public ShaderNode {
 626 public:
 627         SHADER_NODE_CLASS(ParticleInfoNode)
 628         void attributes(Shader *shader, AttributeRequestSet *attributes);
 629         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 630 };
 631
 632 class HairInfoNode : public ShaderNode {
 633 public:
 634         SHADER_NODE_CLASS(HairInfoNode)
 635
 636         void attributes(Shader *shader, AttributeRequestSet *attributes);
 637         bool has_spatial_varying() { return true; }
 638         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 639         virtual int get_feature() {
 640                 return ShaderNode::get_feature() | NODE_FEATURE_HAIR;
 641         }
 642 };
 643
 644 class ValueNode : public ShaderNode {
 645 public:
 646         SHADER_NODE_CLASS(ValueNode)
 647
 648         void constant_fold(const ConstantFolder& folder);
 649
 650         float value;
 651 };
 652
 653 class ColorNode : public ShaderNode {
 654 public:
 655         SHADER_NODE_CLASS(ColorNode)
 656
 657         void constant_fold(const ConstantFolder& folder);
 658
 659         float3 value;
 660 };
 661
 662 class AddClosureNode : public ShaderNode {
 663 public:
 664         SHADER_NODE_CLASS(AddClosureNode)
 665         void constant_fold(const ConstantFolder& folder);
 666 };
 667
 668 class MixClosureNode : public ShaderNode {
 669 public:
 670         SHADER_NODE_CLASS(MixClosureNode)
 671         void constant_fold(const ConstantFolder& folder);
 672
 673         float fac;
 674 };
 675
 676 class MixClosureWeightNode : public ShaderNode {
 677 public:
 678         SHADER_NODE_CLASS(MixClosureWeightNode)
 679
 680         float weight;
 681         float fac;
 682 };
 683
 684 class InvertNode : public ShaderNode {
 685 public:
 686         SHADER_NODE_CLASS(InvertNode)
 687         void constant_fold(const ConstantFolder& folder);
 688         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 689
 690         float fac;
 691         float3 color;
 692 };
 693
 694 class MixNode : public ShaderNode {
 695 public:
 696         SHADER_NODE_CLASS(MixNode)
 697         void constant_fold(const ConstantFolder& folder);
 698
 699         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 700
 701         NodeMix type;
 702         bool use_clamp;
 703         float3 color1;
 704         float3 color2;
 705         float fac;
 706 };
 707
 708 class CombineRGBNode : public ShaderNode {
 709 public:
 710         SHADER_NODE_CLASS(CombineRGBNode)
 711         void constant_fold(const ConstantFolder& folder);
 712         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 713
 714         float r, g, b;
 715 };
 716
 717 class CombineHSVNode : public ShaderNode {
 718 public:
 719         SHADER_NODE_CLASS(CombineHSVNode)
 720         void constant_fold(const ConstantFolder& folder);
 721         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 722
 723         float h, s, v;
 724 };
 725
 726 class CombineXYZNode : public ShaderNode {
 727 public:
 728         SHADER_NODE_CLASS(CombineXYZNode)
 729         void constant_fold(const ConstantFolder& folder);
 730         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 731
 732         float x, y, z;
 733 };
 734
 735 class GammaNode : public ShaderNode {
 736 public:
 737         SHADER_NODE_CLASS(GammaNode)
 738         void constant_fold(const ConstantFolder& folder);
 739         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 740
 741         float3 color;
 742         float gamma;
 743 };
 744
 745 class BrightContrastNode : public ShaderNode {
 746 public:
 747         SHADER_NODE_CLASS(BrightContrastNode)
 748         void constant_fold(const ConstantFolder& folder);
 749         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 750
 751         float3 color;
 752         float bright;
 753         float contrast;
 754 };
 755
 756 class SeparateRGBNode : public ShaderNode {
 757 public:
 758         SHADER_NODE_CLASS(SeparateRGBNode)
 759         void constant_fold(const ConstantFolder& folder);
 760         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 761
 762         float3 color;
 763 };
 764
 765 class SeparateHSVNode : public ShaderNode {
 766 public:
 767         SHADER_NODE_CLASS(SeparateHSVNode)
 768         void constant_fold(const ConstantFolder& folder);
 769         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 770
 771         float3 color;
 772 };
 773
 774 class SeparateXYZNode : public ShaderNode {
 775 public:
 776         SHADER_NODE_CLASS(SeparateXYZNode)
 777         void constant_fold(const ConstantFolder& folder);
 778         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 779
 780         float3 vector;
 781 };
 782
 783 class HSVNode : public ShaderNode {
 784 public:
 785         SHADER_NODE_CLASS(HSVNode)
 786
 787         float hue;
 788         float saturation;
 789         float value;
 790         float fac;
 791         float3 color;
 792 };
 793
 794 class AttributeNode : public ShaderNode {
 795 public:
 796         SHADER_NODE_CLASS(AttributeNode)
 797         void attributes(Shader *shader, AttributeRequestSet *attributes);
 798         bool has_spatial_varying() { return true; }
 799
 800         ustring attribute;
 801 };
 802
 803 class CameraNode : public ShaderNode {
 804 public:
 805         SHADER_NODE_CLASS(CameraNode)
 806         bool has_spatial_varying() { return true; }
 807         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
 808 };
 809
 810 class FresnelNode : public ShaderNode {
 811 public:
 812         SHADER_NODE_CLASS(FresnelNode)
 813         bool has_spatial_varying() { return true; }
 814         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 815
 816         float3 normal;
 817         float IOR;
 818 };
 819
 820 class LayerWeightNode : public ShaderNode {
 821 public:
 822         SHADER_NODE_CLASS(LayerWeightNode)
 823         bool has_spatial_varying() { return true; }
 824         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 825
 826         float3 normal;
 827         float blend;
 828 };
 829
 830 class WireframeNode : public ShaderNode {
 831 public:
 832         SHADER_NODE_CLASS(WireframeNode)
 833         bool has_spatial_varying() { return true; }
 834         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 835
 836         float size;
 837         bool use_pixel_size;
 838 };
 839
 840 class WavelengthNode : public ShaderNode {
 841 public:
 842         SHADER_NODE_CLASS(WavelengthNode)
 843         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 844
 845         float wavelength;
 846 };
 847
 848 class BlackbodyNode : public ShaderNode {
 849 public:
 850         SHADER_NODE_CLASS(BlackbodyNode)
 851         void constant_fold(const ConstantFolder& folder);
 852         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 853
 854         float temperature;
 855 };
 856
 857 class MathNode : public ShaderNode {
 858 public:
 859         SHADER_NODE_CLASS(MathNode)
 860         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 861         void constant_fold(const ConstantFolder& folder);
 862
 863         float value1;
 864         float value2;
 865         NodeMath type;
 866         bool use_clamp;
 867 };
 868
 869 class NormalNode : public ShaderNode {
 870 public:
 871         SHADER_NODE_CLASS(NormalNode)
 872         virtual int get_group() { return NODE_GROUP_LEVEL_2; }
 873
 874         float3 direction;
 875         float3 normal;
 876 };
 877
 878 class VectorMathNode : public ShaderNode {
 879 public:
 880         SHADER_NODE_CLASS(VectorMathNode)
 881         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 882         void constant_fold(const ConstantFolder& folder);
 883
 884         float3 vector1;
 885         float3 vector2;
 886         NodeVectorMath type;
 887 };
 888
 889 class VectorTransformNode : public ShaderNode {
 890 public:
 891         SHADER_NODE_CLASS(VectorTransformNode)
 892
 893         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 894
 895         NodeVectorTransformType type;
 896         NodeVectorTransformConvertSpace convert_from;
 897         NodeVectorTransformConvertSpace convert_to;
 898         float3 vector;
 899 };
 900
 901 class BumpNode : public ShaderNode {
 902 public:
 903         SHADER_NODE_CLASS(BumpNode)
 904         void constant_fold(const ConstantFolder& folder);
 905         bool has_spatial_varying() { return true; }
 906         virtual int get_feature() {
 907                 return NODE_FEATURE_BUMP;
 908         }
 909
 910         bool invert;
 911         bool use_object_space;
 912         float height;
 913         float sample_center;
 914         float sample_x;
 915         float sample_y;
 916         float3 normal;
 917         float strength;
 918         float distance;
 919 };
 920
 921 class CurvesNode : public ShaderNode {
 922 public:
 923         explicit CurvesNode(const NodeType *node_type);
 924         SHADER_NODE_BASE_CLASS(CurvesNode)
 925
 926         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 927
 928         array<float3> curves;
 929         float min_x, max_x, fac;
 930         float3 value;
 931
 932 protected:
 933         void constant_fold(const ConstantFolder& folder, ShaderInput *value_in);
 934         void compile(SVMCompiler& compiler, int type, ShaderInput *value_in, ShaderOutput *value_out);
 935         void compile(OSLCompiler& compiler, const char *name);
 936 };
 937
 938 class RGBCurvesNode : public CurvesNode {
 939 public:
 940         SHADER_NODE_CLASS(RGBCurvesNode)
 941         void constant_fold(const ConstantFolder& folder);
 942 };
 943
 944 class VectorCurvesNode : public CurvesNode {
 945 public:
 946         SHADER_NODE_CLASS(VectorCurvesNode)
 947         void constant_fold(const ConstantFolder& folder);
 948 };
 949
 950 class RGBRampNode : public ShaderNode {
 951 public:
 952         SHADER_NODE_CLASS(RGBRampNode)
 953         void constant_fold(const ConstantFolder& folder);
 954         virtual int get_group() { return NODE_GROUP_LEVEL_1; }
 955
 956         array<float3> ramp;
 957         array<float> ramp_alpha;
 958         float fac;
 959         bool interpolate;
 960 };
 961
 962 class SetNormalNode : public ShaderNode {
 963 public:
 964         SHADER_NODE_CLASS(SetNormalNode)
 965         float3 direction;
 966 };
 967
 968 class OSLNode : public ShaderNode {
 969 public:
 970         static OSLNode *create(size_t num_inputs, const OSLNode *from = NULL);
 971         ~OSLNode();
 972
 973         ShaderNode *clone() const;
 974
 975         char* input_default_value();
 976         void add_input(ustring name, SocketType::Type type);
 977         void add_output(ustring name, SocketType::Type type);
 978
 979         SHADER_NODE_NO_CLONE_CLASS(OSLNode)
 980
 981         /* ideally we could beter detect this, but we can't query this now */
 982         bool has_spatial_varying() { return true; }
 983         bool has_volume_support() { return true; }
 984
 985         virtual bool equals(const ShaderNode& /*other*/) { return false; }
 986
 987         string filepath;
 988         string bytecode_hash;
 989 };
 990
 991 class NormalMapNode : public ShaderNode {
 992 public:
 993         SHADER_NODE_CLASS(NormalMapNode)
 994         void attributes(Shader *shader, AttributeRequestSet *attributes);
 995         bool has_spatial_varying() { return true; }
 996         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
 997
 998         NodeNormalMapSpace space;
 999         ustring attribute;
1000         float strength;
1001         float3 color;
1002         float3 normal_osl;
1003 };
1004
1005 class TangentNode : public ShaderNode {
1006 public:
1007         SHADER_NODE_CLASS(TangentNode)
1008         void attributes(Shader *shader, AttributeRequestSet *attributes);
1009         bool has_spatial_varying() { return true; }
1010         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
1011
1012         NodeTangentDirectionType direction_type;
1013         NodeTangentAxis axis;
1014         ustring attribute;
1015         float3 normal_osl;
1016 };
1017
1018 class BevelNode : public ShaderNode {
1019 public:
1020         SHADER_NODE_CLASS(BevelNode)
1021         bool has_spatial_varying() { return true; }
1022         virtual int get_group() { return NODE_GROUP_LEVEL_3; }
1023         virtual bool has_raytrace() { return true; }
1024
1025         float radius;
1026         float3 normal;
1027         int samples;
1028 };
1029
1030 class DisplacementNode : public ShaderNode {
1031 public:
1032         SHADER_NODE_CLASS(DisplacementNode)
1033         virtual int get_feature() {
1034                 return NODE_FEATURE_BUMP;
1035         }
1036
1037         float height;
1038         float scale;
1039         float3 normal;
1040 };
1041
1042 CCL_NAMESPACE_END
1043
1044 #endif /* __NODES_H__ */
1045