ClangFormat: apply to source, most of intern
[blender.git] / intern / cycles / render / nodes.h
index 5571c52..7796711 100644 (file)
@@ -33,1137 +33,1459 @@ class Shader;
 /* Texture Mapping */
 
 class TextureMapping {
-public:
-       TextureMapping();
-       Transform compute_transform();
-       bool skip();
-       void compile(SVMCompiler& compiler, int offset_in, int offset_out);
-       int compile(SVMCompiler& compiler, ShaderInput *vector_in);
-       void compile(OSLCompiler &compiler);
+ public:
+  TextureMapping();
+  Transform compute_transform();
+  bool skip();
+  void compile(SVMCompiler &compiler, int offset_in, int offset_out);
+  int compile(SVMCompiler &compiler, ShaderInput *vector_in);
+  void compile(OSLCompiler &compiler);
 
-       int compile_begin(SVMCompiler& compiler, ShaderInput *vector_in);
-       void compile_end(SVMCompiler& compiler, ShaderInput *vector_in, int vector_offset);
+  int compile_begin(SVMCompiler &compiler, ShaderInput *vector_in);
+  void compile_end(SVMCompiler &compiler, ShaderInput *vector_in, int vector_offset);
 
-       float3 translation;
-       float3 rotation;
-       float3 scale;
+  float3 translation;
+  float3 rotation;
+  float3 scale;
 
-       float3 min, max;
-       bool use_minmax;
+  float3 min, max;
+  bool use_minmax;
 
-       enum Type { POINT = 0, TEXTURE = 1, VECTOR = 2, NORMAL = 3 };
-       Type type;
+  enum Type { POINT = 0, TEXTURE = 1, VECTOR = 2, NORMAL = 3 };
+  Type type;
 
-       enum Mapping { NONE = 0, X = 1, Y = 2, Z = 3 };
-       Mapping x_mapping, y_mapping, z_mapping;
+  enum Mapping { NONE = 0, X = 1, Y = 2, Z = 3 };
+  Mapping x_mapping, y_mapping, z_mapping;
 
-       enum Projection { FLAT, CUBE, TUBE, SPHERE };
-       Projection projection;
+  enum Projection { FLAT, CUBE, TUBE, SPHERE };
+  Projection projection;
 };
 
 /* Nodes */
 
 class TextureNode : public ShaderNode {
-public:
-       explicit TextureNode(const NodeType *node_type) : ShaderNode(node_type) {}
-       TextureMapping tex_mapping;
+ public:
+  explicit TextureNode(const NodeType *node_type) : ShaderNode(node_type)
+  {
+  }
+  TextureMapping tex_mapping;
 };
 
 /* Any node which uses image manager's slot should be a subclass of this one. */
 class ImageSlotTextureNode : public TextureNode {
-public:
-       explicit ImageSlotTextureNode(const NodeType *node_type) : TextureNode(node_type) {
-               special_type = SHADER_SPECIAL_TYPE_IMAGE_SLOT;
-       }
-       int slot;
+ public:
+  explicit ImageSlotTextureNode(const NodeType *node_type) : TextureNode(node_type)
+  {
+    special_type = SHADER_SPECIAL_TYPE_IMAGE_SLOT;
+  }
+  int slot;
 };
 
 class ImageTextureNode : public ImageSlotTextureNode {
-public:
-       SHADER_NODE_NO_CLONE_CLASS(ImageTextureNode)
-       ~ImageTextureNode();
-       ShaderNode *clone() const;
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
-
-       ImageManager *image_manager;
-       int is_float;
-       bool is_linear;
-       bool use_alpha;
-       ustring filename;
-       void *builtin_data;
-       NodeImageColorSpace color_space;
-       NodeImageProjection projection;
-       InterpolationType interpolation;
-       ExtensionType extension;
-       float projection_blend;
-       bool animated;
-       float3 vector;
-
-       virtual bool equals(const ShaderNode& other)
-       {
-               const ImageTextureNode& image_node = (const ImageTextureNode&)other;
-               return ImageSlotTextureNode::equals(other) &&
-                      builtin_data == image_node.builtin_data &&
-                      animated == image_node.animated;
-       }
+ public:
+  SHADER_NODE_NO_CLONE_CLASS(ImageTextureNode)
+  ~ImageTextureNode();
+  ShaderNode *clone() const;
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
+
+  ImageManager *image_manager;
+  int is_float;
+  bool is_linear;
+  bool use_alpha;
+  ustring filename;
+  void *builtin_data;
+  NodeImageColorSpace color_space;
+  NodeImageProjection projection;
+  InterpolationType interpolation;
+  ExtensionType extension;
+  float projection_blend;
+  bool animated;
+  float3 vector;
+
+  virtual bool equals(const ShaderNode &other)
+  {
+    const ImageTextureNode &image_node = (const ImageTextureNode &)other;
+    return ImageSlotTextureNode::equals(other) && builtin_data == image_node.builtin_data &&
+           animated == image_node.animated;
+  }
 };
 
 class EnvironmentTextureNode : public ImageSlotTextureNode {
-public:
-       SHADER_NODE_NO_CLONE_CLASS(EnvironmentTextureNode)
-       ~EnvironmentTextureNode();
-       ShaderNode *clone() const;
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
-       virtual int get_group() { return NODE_GROUP_LEVEL_2; }
-
-       ImageManager *image_manager;
-       int is_float;
-       bool is_linear;
-       bool use_alpha;
-       ustring filename;
-       void *builtin_data;
-       NodeImageColorSpace color_space;
-       NodeEnvironmentProjection projection;
-       InterpolationType interpolation;
-       bool animated;
-       float3 vector;
-
-       virtual bool equals(const ShaderNode& other)
-       {
-               const EnvironmentTextureNode& env_node = (const EnvironmentTextureNode&)other;
-               return ImageSlotTextureNode::equals(other) &&
-                      builtin_data == env_node.builtin_data &&
-                      animated == env_node.animated;
-       }
+ public:
+  SHADER_NODE_NO_CLONE_CLASS(EnvironmentTextureNode)
+  ~EnvironmentTextureNode();
+  ShaderNode *clone() const;
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_2;
+  }
+
+  ImageManager *image_manager;
+  int is_float;
+  bool is_linear;
+  bool use_alpha;
+  ustring filename;
+  void *builtin_data;
+  NodeImageColorSpace color_space;
+  NodeEnvironmentProjection projection;
+  InterpolationType interpolation;
+  bool animated;
+  float3 vector;
+
+  virtual bool equals(const ShaderNode &other)
+  {
+    const EnvironmentTextureNode &env_node = (const EnvironmentTextureNode &)other;
+    return ImageSlotTextureNode::equals(other) && builtin_data == env_node.builtin_data &&
+           animated == env_node.animated;
+  }
 };
 
 class SkyTextureNode : public TextureNode {
-public:
-       SHADER_NODE_CLASS(SkyTextureNode)
+ public:
+  SHADER_NODE_CLASS(SkyTextureNode)
 
-       virtual int get_group() { return NODE_GROUP_LEVEL_2; }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_2;
+  }
 
-       NodeSkyType type;
-       float3 sun_direction;
-       float turbidity;
-       float ground_albedo;
-       float3 vector;
+  NodeSkyType type;
+  float3 sun_direction;
+  float turbidity;
+  float ground_albedo;
+  float3 vector;
 };
 
 class OutputNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(OutputNode)
+ public:
+  SHADER_NODE_CLASS(OutputNode)
 
-       void *surface;
-       void *volume;
-       float3 displacement;
-       float3 normal;
+  void *surface;
+  void *volume;
+  float3 displacement;
+  float3 normal;
 
-       /* Don't allow output node de-duplication. */
-       virtual bool equals(const ShaderNode& /*other*/) { return false; }
+  /* Don't allow output node de-duplication. */
+  virtual bool equals(const ShaderNode & /*other*/)
+  {
+    return false;
+  }
 };
 
 class GradientTextureNode : public TextureNode {
-public:
-       SHADER_NODE_CLASS(GradientTextureNode)
+ public:
+  SHADER_NODE_CLASS(GradientTextureNode)
 
-       virtual int get_group() { return NODE_GROUP_LEVEL_2; }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_2;
+  }
 
-       NodeGradientType type;
-       float3 vector;
+  NodeGradientType type;
+  float3 vector;
 };
 
 class NoiseTextureNode : public TextureNode {
-public:
-       SHADER_NODE_CLASS(NoiseTextureNode)
+ public:
+  SHADER_NODE_CLASS(NoiseTextureNode)
 
-       float scale, detail, distortion;
-       float3 vector;
+  float scale, detail, distortion;
+  float3 vector;
 };
 
 class VoronoiTextureNode : public TextureNode {
-public:
-       SHADER_NODE_CLASS(VoronoiTextureNode)
+ public:
+  SHADER_NODE_CLASS(VoronoiTextureNode)
 
-       virtual int get_group() { return NODE_GROUP_LEVEL_2; }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_2;
+  }
 
-       NodeVoronoiColoring coloring;
-       NodeVoronoiDistanceMetric metric;
-       NodeVoronoiFeature feature;
-       float scale, exponent;
-       float3 vector;
+  NodeVoronoiColoring coloring;
+  NodeVoronoiDistanceMetric metric;
+  NodeVoronoiFeature feature;
+  float scale, exponent;
+  float3 vector;
 };
 
 class MusgraveTextureNode : public TextureNode {
-public:
-       SHADER_NODE_CLASS(MusgraveTextureNode)
+ public:
+  SHADER_NODE_CLASS(MusgraveTextureNode)
 
-       virtual int get_group() { return NODE_GROUP_LEVEL_2; }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_2;
+  }
 
-       NodeMusgraveType type;
-       float scale, detail, dimension, lacunarity, offset, gain;
-       float3 vector;
+  NodeMusgraveType type;
+  float scale, detail, dimension, lacunarity, offset, gain;
+  float3 vector;
 };
 
 class WaveTextureNode : public TextureNode {
-public:
-       SHADER_NODE_CLASS(WaveTextureNode)
+ public:
+  SHADER_NODE_CLASS(WaveTextureNode)
 
-       virtual int get_group() { return NODE_GROUP_LEVEL_2; }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_2;
+  }
 
-       NodeWaveType type;
-       NodeWaveProfile profile;
+  NodeWaveType type;
+  NodeWaveProfile profile;
 
-       float scale, distortion, detail, detail_scale;
-       float3 vector;
+  float scale, distortion, detail, detail_scale;
+  float3 vector;
 };
 
 class MagicTextureNode : public TextureNode {
-public:
-       SHADER_NODE_CLASS(MagicTextureNode)
+ public:
+  SHADER_NODE_CLASS(MagicTextureNode)
 
-       virtual int get_group() { return NODE_GROUP_LEVEL_2; }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_2;
+  }
 
-       int depth;
-       float3 vector;
-       float scale, distortion;
+  int depth;
+  float3 vector;
+  float scale, distortion;
 };
 
 class CheckerTextureNode : public TextureNode {
-public:
-       SHADER_NODE_CLASS(CheckerTextureNode)
+ public:
+  SHADER_NODE_CLASS(CheckerTextureNode)
 
-       float3 vector, color1, color2;
-       float scale;
+  float3 vector, color1, color2;
+  float scale;
 
-       virtual int get_group() { return NODE_GROUP_LEVEL_2; }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_2;
+  }
 };
 
 class BrickTextureNode : public TextureNode {
-public:
-       SHADER_NODE_CLASS(BrickTextureNode)
+ public:
+  SHADER_NODE_CLASS(BrickTextureNode)
 
-       float offset, squash;
-       int offset_frequency, squash_frequency;
+  float offset, squash;
+  int offset_frequency, squash_frequency;
 
-       float3 color1, color2, mortar;
-       float scale, mortar_size, mortar_smooth, bias, brick_width, row_height;
-       float3 vector;
+  float3 color1, color2, mortar;
+  float scale, mortar_size, mortar_smooth, bias, brick_width, row_height;
+  float3 vector;
 
-       virtual int get_group() { return NODE_GROUP_LEVEL_2; }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_2;
+  }
 };
 
 class PointDensityTextureNode : public ShaderNode {
-public:
-       SHADER_NODE_NO_CLONE_CLASS(PointDensityTextureNode)
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
-
-       ~PointDensityTextureNode();
-       ShaderNode *clone() const;
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
-
-       bool has_spatial_varying() { return true; }
-       bool has_object_dependency() { return true; }
-
-       void add_image();
-
-       ustring filename;
-       NodeTexVoxelSpace space;
-       InterpolationType interpolation;
-       Transform tfm;
-       float3 vector;
-
-       ImageManager *image_manager;
-       int slot;
-       void *builtin_data;
-
-       virtual bool equals(const ShaderNode& other) {
-               const PointDensityTextureNode& point_dendity_node = (const PointDensityTextureNode&)other;
-               return ShaderNode::equals(other) &&
-                      builtin_data == point_dendity_node.builtin_data;
-       }
+ public:
+  SHADER_NODE_NO_CLONE_CLASS(PointDensityTextureNode)
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
+
+  ~PointDensityTextureNode();
+  ShaderNode *clone() const;
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
+
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  bool has_object_dependency()
+  {
+    return true;
+  }
+
+  void add_image();
+
+  ustring filename;
+  NodeTexVoxelSpace space;
+  InterpolationType interpolation;
+  Transform tfm;
+  float3 vector;
+
+  ImageManager *image_manager;
+  int slot;
+  void *builtin_data;
+
+  virtual bool equals(const ShaderNode &other)
+  {
+    const PointDensityTextureNode &point_dendity_node = (const PointDensityTextureNode &)other;
+    return ShaderNode::equals(other) && builtin_data == point_dendity_node.builtin_data;
+  }
 };
 
 class IESLightNode : public TextureNode {
-public:
-       SHADER_NODE_NO_CLONE_CLASS(IESLightNode)
+ public:
+  SHADER_NODE_NO_CLONE_CLASS(IESLightNode)
 
-       ~IESLightNode();
-       ShaderNode *clone() const;
-       virtual int get_group() { return NODE_GROUP_LEVEL_2; }
+  ~IESLightNode();
+  ShaderNode *clone() const;
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_2;
+  }
 
-       ustring filename;
-       ustring ies;
+  ustring filename;
+  ustring ies;
 
-       float strength;
-       float3 vector;
+  float strength;
+  float3 vector;
 
-private:
-       LightManager *light_manager;
-       int slot;
+ private:
+  LightManager *light_manager;
+  int slot;
 
-       void get_slot();
+  void get_slot();
 };
 
 class MappingNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(MappingNode)
-       virtual int get_group() { return NODE_GROUP_LEVEL_2; }
+ public:
+  SHADER_NODE_CLASS(MappingNode)
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_2;
+  }
 
-       float3 vector;
-       TextureMapping tex_mapping;
+  float3 vector;
+  TextureMapping tex_mapping;
 };
 
 class RGBToBWNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(RGBToBWNode)
-       void constant_fold(const ConstantFolder& folder);
+ public:
+  SHADER_NODE_CLASS(RGBToBWNode)
+  void constant_fold(const ConstantFolder &folder);
 
-       float3 color;
+  float3 color;
 };
 
 class ConvertNode : public ShaderNode {
-public:
-       ConvertNode(SocketType::Type from, SocketType::Type to, bool autoconvert = false);
-       SHADER_NODE_BASE_CLASS(ConvertNode)
+ public:
+  ConvertNode(SocketType::Type from, SocketType::Type to, bool autoconvert = false);
+  SHADER_NODE_BASE_CLASS(ConvertNode)
 
-       void constant_fold(const ConstantFolder& folder);
+  void constant_fold(const ConstantFolder &folder);
 
-       SocketType::Type from, to;
+  SocketType::Type from, to;
 
-       union {
-               float value_float;
-               int value_int;
-               float3 value_color;
-               float3 value_vector;
-               float3 value_point;
-               float3 value_normal;
-       };
-       ustring value_string;
+  union {
+    float value_float;
+    int value_int;
+    float3 value_color;
+    float3 value_vector;
+    float3 value_point;
+    float3 value_normal;
+  };
+  ustring value_string;
 
-private:
-       static const int MAX_TYPE = 12;
-       static bool register_types();
-       static Node* create(const NodeType *type);
-       static const NodeType *node_types[MAX_TYPE][MAX_TYPE];
-       static bool initialized;
+ private:
+  static const int MAX_TYPE = 12;
+  static bool register_types();
+  static Node *create(const NodeType *type);
+  static const NodeType *node_types[MAX_TYPE][MAX_TYPE];
+  static bool initialized;
 };
 
 class BsdfBaseNode : public ShaderNode {
-public:
-       BsdfBaseNode(const NodeType *node_type);
+ public:
+  BsdfBaseNode(const NodeType *node_type);
 
-       bool has_spatial_varying() { return true; }
-       virtual ClosureType get_closure_type() { return closure; }
-       virtual bool has_bump();
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  virtual ClosureType get_closure_type()
+  {
+    return closure;
+  }
+  virtual bool has_bump();
 
-       virtual bool equals(const ShaderNode& /*other*/)
-       {
-               /* TODO(sergey): With some care BSDF nodes can be de-duplicated. */
-               return false;
-       }
+  virtual bool equals(const ShaderNode & /*other*/)
+  {
+    /* TODO(sergey): With some care BSDF nodes can be de-duplicated. */
+    return false;
+  }
 
-       ClosureType closure;
+  ClosureType closure;
 };
 
 class BsdfNode : public BsdfBaseNode {
-public:
-       explicit BsdfNode(const NodeType *node_type);
-       SHADER_NODE_BASE_CLASS(BsdfNode)
+ public:
+  explicit BsdfNode(const NodeType *node_type);
+  SHADER_NODE_BASE_CLASS(BsdfNode)
 
-       void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2, ShaderInput *param3 = NULL, ShaderInput *param4 = NULL);
+  void compile(SVMCompiler &compiler,
+               ShaderInput *param1,
+               ShaderInput *param2,
+               ShaderInput *param3 = NULL,
+               ShaderInput *param4 = NULL);
 
-       float3 color;
-       float3 normal;
-       float surface_mix_weight;
+  float3 color;
+  float3 normal;
+  float surface_mix_weight;
 };
 
 class AnisotropicBsdfNode : public BsdfNode {
-public:
-       SHADER_NODE_CLASS(AnisotropicBsdfNode)
+ public:
+  SHADER_NODE_CLASS(AnisotropicBsdfNode)
 
-       float3 tangent;
-       float roughness, anisotropy, rotation;
-       ClosureType distribution;
+  float3 tangent;
+  float roughness, anisotropy, rotation;
+  ClosureType distribution;
 
-       ClosureType get_closure_type() { return distribution; }
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
+  ClosureType get_closure_type()
+  {
+    return distribution;
+  }
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
 };
 
 class DiffuseBsdfNode : public BsdfNode {
-public:
-       SHADER_NODE_CLASS(DiffuseBsdfNode)
+ public:
+  SHADER_NODE_CLASS(DiffuseBsdfNode)
 
-       float roughness;
+  float roughness;
 };
 
 /* Disney principled BRDF */
 class PrincipledBsdfNode : public BsdfBaseNode {
-public:
-       SHADER_NODE_CLASS(PrincipledBsdfNode)
-
-       bool has_surface_bssrdf();
-       bool has_bssrdf_bump();
-       void compile(SVMCompiler& compiler, ShaderInput *metallic, ShaderInput *subsurface, ShaderInput *subsurface_radius,
-               ShaderInput *specular, ShaderInput *roughness, ShaderInput *specular_tint, ShaderInput *anisotropic,
-               ShaderInput *sheen, ShaderInput *sheen_tint, ShaderInput *clearcoat, ShaderInput *clearcoat_roughness,
-               ShaderInput *ior, ShaderInput *transmission, ShaderInput *anisotropic_rotation, ShaderInput *transmission_roughness);
-
-       float3 base_color;
-       float3 subsurface_color, subsurface_radius;
-       float metallic, subsurface, specular, roughness, specular_tint, anisotropic,
-               sheen, sheen_tint, clearcoat, clearcoat_roughness, ior, transmission,
-               anisotropic_rotation, transmission_roughness;
-       float3 normal, clearcoat_normal, tangent;
-       float surface_mix_weight;
-       ClosureType distribution, distribution_orig;
-       ClosureType subsurface_method;
-
-       bool has_integrator_dependency();
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
+ public:
+  SHADER_NODE_CLASS(PrincipledBsdfNode)
+
+  bool has_surface_bssrdf();
+  bool has_bssrdf_bump();
+  void compile(SVMCompiler &compiler,
+               ShaderInput *metallic,
+               ShaderInput *subsurface,
+               ShaderInput *subsurface_radius,
+               ShaderInput *specular,
+               ShaderInput *roughness,
+               ShaderInput *specular_tint,
+               ShaderInput *anisotropic,
+               ShaderInput *sheen,
+               ShaderInput *sheen_tint,
+               ShaderInput *clearcoat,
+               ShaderInput *clearcoat_roughness,
+               ShaderInput *ior,
+               ShaderInput *transmission,
+               ShaderInput *anisotropic_rotation,
+               ShaderInput *transmission_roughness);
+
+  float3 base_color;
+  float3 subsurface_color, subsurface_radius;
+  float metallic, subsurface, specular, roughness, specular_tint, anisotropic, sheen, sheen_tint,
+      clearcoat, clearcoat_roughness, ior, transmission, anisotropic_rotation,
+      transmission_roughness;
+  float3 normal, clearcoat_normal, tangent;
+  float surface_mix_weight;
+  ClosureType distribution, distribution_orig;
+  ClosureType subsurface_method;
+
+  bool has_integrator_dependency();
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
 };
 
 class TranslucentBsdfNode : public BsdfNode {
-public:
-       SHADER_NODE_CLASS(TranslucentBsdfNode)
+ public:
+  SHADER_NODE_CLASS(TranslucentBsdfNode)
 };
 
 class TransparentBsdfNode : public BsdfNode {
-public:
-       SHADER_NODE_CLASS(TransparentBsdfNode)
+ public:
+  SHADER_NODE_CLASS(TransparentBsdfNode)
 
-       bool has_surface_transparent() { return true; }
+  bool has_surface_transparent()
+  {
+    return true;
+  }
 };
 
 class VelvetBsdfNode : public BsdfNode {
-public:
-       SHADER_NODE_CLASS(VelvetBsdfNode)
+ public:
+  SHADER_NODE_CLASS(VelvetBsdfNode)
 
-       float sigma;
+  float sigma;
 };
 
 class GlossyBsdfNode : public BsdfNode {
-public:
-       SHADER_NODE_CLASS(GlossyBsdfNode)
+ public:
+  SHADER_NODE_CLASS(GlossyBsdfNode)
 
-       void simplify_settings(Scene *scene);
-       bool has_integrator_dependency();
-       ClosureType get_closure_type() { return distribution; }
+  void simplify_settings(Scene *scene);
+  bool has_integrator_dependency();
+  ClosureType get_closure_type()
+  {
+    return distribution;
+  }
 
-       float roughness, roughness_orig;
-       ClosureType distribution, distribution_orig;
+  float roughness, roughness_orig;
+  ClosureType distribution, distribution_orig;
 };
 
 class GlassBsdfNode : public BsdfNode {
-public:
-       SHADER_NODE_CLASS(GlassBsdfNode)
+ public:
+  SHADER_NODE_CLASS(GlassBsdfNode)
 
-       void simplify_settings(Scene *scene);
-       bool has_integrator_dependency();
-       ClosureType get_closure_type() { return distribution; }
+  void simplify_settings(Scene *scene);
+  bool has_integrator_dependency();
+  ClosureType get_closure_type()
+  {
+    return distribution;
+  }
 
-       float roughness, roughness_orig, IOR;
-       ClosureType distribution, distribution_orig;
+  float roughness, roughness_orig, IOR;
+  ClosureType distribution, distribution_orig;
 };
 
 class RefractionBsdfNode : public BsdfNode {
-public:
-       SHADER_NODE_CLASS(RefractionBsdfNode)
+ public:
+  SHADER_NODE_CLASS(RefractionBsdfNode)
 
-       void simplify_settings(Scene *scene);
-       bool has_integrator_dependency();
-       ClosureType get_closure_type() { return distribution; }
+  void simplify_settings(Scene *scene);
+  bool has_integrator_dependency();
+  ClosureType get_closure_type()
+  {
+    return distribution;
+  }
 
-       float roughness, roughness_orig, IOR;
-       ClosureType distribution, distribution_orig;
+  float roughness, roughness_orig, IOR;
+  ClosureType distribution, distribution_orig;
 };
 
 class ToonBsdfNode : public BsdfNode {
-public:
-       SHADER_NODE_CLASS(ToonBsdfNode)
+ public:
+  SHADER_NODE_CLASS(ToonBsdfNode)
 
-       float smooth, size;
-       ClosureType component;
+  float smooth, size;
+  ClosureType component;
 };
 
 class SubsurfaceScatteringNode : public BsdfNode {
-public:
-       SHADER_NODE_CLASS(SubsurfaceScatteringNode)
-       bool has_surface_bssrdf() { return true; }
-       bool has_bssrdf_bump();
-       ClosureType get_closure_type() { return falloff; }
-
-       float scale;
-       float3 radius;
-       float sharpness;
-       float texture_blur;
-       ClosureType falloff;
+ public:
+  SHADER_NODE_CLASS(SubsurfaceScatteringNode)
+  bool has_surface_bssrdf()
+  {
+    return true;
+  }
+  bool has_bssrdf_bump();
+  ClosureType get_closure_type()
+  {
+    return falloff;
+  }
+
+  float scale;
+  float3 radius;
+  float sharpness;
+  float texture_blur;
+  ClosureType falloff;
 };
 
 class EmissionNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(EmissionNode)
-       void constant_fold(const ConstantFolder& folder);
+ public:
+  SHADER_NODE_CLASS(EmissionNode)
+  void constant_fold(const ConstantFolder &folder);
 
-       bool has_surface_emission() { return true; }
-       bool has_volume_support() { return true; }
+  bool has_surface_emission()
+  {
+    return true;
+  }
+  bool has_volume_support()
+  {
+    return true;
+  }
 
-       float3 color;
-       float strength;
-       float surface_mix_weight;
+  float3 color;
+  float strength;
+  float surface_mix_weight;
 };
 
 class BackgroundNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(BackgroundNode)
-       void constant_fold(const ConstantFolder& folder);
+ public:
+  SHADER_NODE_CLASS(BackgroundNode)
+  void constant_fold(const ConstantFolder &folder);
 
-       float3 color;
-       float strength;
-       float surface_mix_weight;
+  float3 color;
+  float strength;
+  float surface_mix_weight;
 };
 
 class HoldoutNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(HoldoutNode)
-       virtual int get_group() { return NODE_GROUP_LEVEL_1; }
-       virtual ClosureType get_closure_type() { return CLOSURE_HOLDOUT_ID; }
+ public:
+  SHADER_NODE_CLASS(HoldoutNode)
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_1;
+  }
+  virtual ClosureType get_closure_type()
+  {
+    return CLOSURE_HOLDOUT_ID;
+  }
 
-       float surface_mix_weight;
-       float volume_mix_weight;
+  float surface_mix_weight;
+  float volume_mix_weight;
 };
 
 class AmbientOcclusionNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(AmbientOcclusionNode)
-
-       bool has_spatial_varying() { return true; }
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
-       virtual bool has_raytrace() { return true; }
-
-       float3 color;
-       float distance;
-       float3 normal;
-       int samples;
-
-       bool only_local;
-       bool inside;
+ public:
+  SHADER_NODE_CLASS(AmbientOcclusionNode)
+
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
+  virtual bool has_raytrace()
+  {
+    return true;
+  }
+
+  float3 color;
+  float distance;
+  float3 normal;
+  int samples;
+
+  bool only_local;
+  bool inside;
 };
 
 class VolumeNode : public ShaderNode {
-public:
-       VolumeNode(const NodeType *node_type);
-       SHADER_NODE_BASE_CLASS(VolumeNode)
-
-       void compile(SVMCompiler& compiler, ShaderInput *param1, ShaderInput *param2);
-       virtual int get_group() { return NODE_GROUP_LEVEL_1; }
-       virtual int get_feature() {
-               return ShaderNode::get_feature() | NODE_FEATURE_VOLUME;
-       }
-       virtual ClosureType get_closure_type() { return closure; }
-       virtual bool has_volume_support() { return true; }
-
-       float3 color;
-       float density;
-       float volume_mix_weight;
-       ClosureType closure;
-
-       virtual bool equals(const ShaderNode& /*other*/)
-       {
-               /* TODO(sergey): With some care Volume nodes can be de-duplicated. */
-               return false;
-       }
+ public:
+  VolumeNode(const NodeType *node_type);
+  SHADER_NODE_BASE_CLASS(VolumeNode)
+
+  void compile(SVMCompiler &compiler, ShaderInput *param1, ShaderInput *param2);
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_1;
+  }
+  virtual int get_feature()
+  {
+    return ShaderNode::get_feature() | NODE_FEATURE_VOLUME;
+  }
+  virtual ClosureType get_closure_type()
+  {
+    return closure;
+  }
+  virtual bool has_volume_support()
+  {
+    return true;
+  }
+
+  float3 color;
+  float density;
+  float volume_mix_weight;
+  ClosureType closure;
+
+  virtual bool equals(const ShaderNode & /*other*/)
+  {
+    /* TODO(sergey): With some care Volume nodes can be de-duplicated. */
+    return false;
+  }
 };
 
 class AbsorptionVolumeNode : public VolumeNode {
-public:
-       SHADER_NODE_CLASS(AbsorptionVolumeNode)
+ public:
+  SHADER_NODE_CLASS(AbsorptionVolumeNode)
 };
 
 class ScatterVolumeNode : public VolumeNode {
-public:
-       SHADER_NODE_CLASS(ScatterVolumeNode)
+ public:
+  SHADER_NODE_CLASS(ScatterVolumeNode)
 
-       float anisotropy;
+  float anisotropy;
 };
 
 class PrincipledVolumeNode : public VolumeNode {
-public:
-       SHADER_NODE_CLASS(PrincipledVolumeNode)
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
-
-       ustring density_attribute;
-       ustring color_attribute;
-       ustring temperature_attribute;
-
-       float anisotropy;
-       float3 absorption_color;
-       float emission_strength;
-       float3 emission_color;
-       float blackbody_intensity;
-       float3 blackbody_tint;
-       float temperature;
+ public:
+  SHADER_NODE_CLASS(PrincipledVolumeNode)
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
+
+  ustring density_attribute;
+  ustring color_attribute;
+  ustring temperature_attribute;
+
+  float anisotropy;
+  float3 absorption_color;
+  float emission_strength;
+  float3 emission_color;
+  float blackbody_intensity;
+  float3 blackbody_tint;
+  float temperature;
 };
 
 /* Interface between the I/O sockets and the SVM/OSL backend. */
 class PrincipledHairBsdfNode : public BsdfBaseNode {
-public:
-       SHADER_NODE_CLASS(PrincipledHairBsdfNode)
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-
-       /* Longitudinal roughness. */
-       float roughness;
-       /* Azimuthal roughness. */
-       float radial_roughness;
-       /* Randomization factor for roughnesses. */
-       float random_roughness;
-       /* Longitudinal roughness factor for only the diffuse bounce (shiny undercoat). */
-       float coat;
-       /* Index of reflection. */
-       float ior;
-       /* Cuticle tilt angle. */
-       float offset;
-       /* Direct coloring's color. */
-       float3 color;
-       /* Melanin concentration. */
-       float melanin;
-       /* Melanin redness ratio. */
-       float melanin_redness;
-       /* Dye color. */
-       float3 tint;
-       /* Randomization factor for melanin quantities. */
-       float random_color;
-       /* Absorption coefficient (unfiltered). */
-       float3 absorption_coefficient;
-
-       float3 normal;
-       float surface_mix_weight;
-       /* If linked, here will be the given random number. */
-       float random;
-       /* Selected coloring parametrization. */
-       NodePrincipledHairParametrization parametrization;
+ public:
+  SHADER_NODE_CLASS(PrincipledHairBsdfNode)
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+
+  /* Longitudinal roughness. */
+  float roughness;
+  /* Azimuthal roughness. */
+  float radial_roughness;
+  /* Randomization factor for roughnesses. */
+  float random_roughness;
+  /* Longitudinal roughness factor for only the diffuse bounce (shiny undercoat). */
+  float coat;
+  /* Index of reflection. */
+  float ior;
+  /* Cuticle tilt angle. */
+  float offset;
+  /* Direct coloring's color. */
+  float3 color;
+  /* Melanin concentration. */
+  float melanin;
+  /* Melanin redness ratio. */
+  float melanin_redness;
+  /* Dye color. */
+  float3 tint;
+  /* Randomization factor for melanin quantities. */
+  float random_color;
+  /* Absorption coefficient (unfiltered). */
+  float3 absorption_coefficient;
+
+  float3 normal;
+  float surface_mix_weight;
+  /* If linked, here will be the given random number. */
+  float random;
+  /* Selected coloring parametrization. */
+  NodePrincipledHairParametrization parametrization;
 };
 
 class HairBsdfNode : public BsdfNode {
-public:
-       SHADER_NODE_CLASS(HairBsdfNode)
-       ClosureType get_closure_type() { return component; }
+ public:
+  SHADER_NODE_CLASS(HairBsdfNode)
+  ClosureType get_closure_type()
+  {
+    return component;
+  }
 
-       ClosureType component;
-       float offset;
-       float roughness_u;
-       float roughness_v;
-       float3 tangent;
+  ClosureType component;
+  float offset;
+  float roughness_u;
+  float roughness_v;
+  float3 tangent;
 };
 
 class GeometryNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(GeometryNode)
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
-       bool has_spatial_varying() { return true; }
-       int get_group();
-
-       float3 normal_osl;
+ public:
+  SHADER_NODE_CLASS(GeometryNode)
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  int get_group();
+
+  float3 normal_osl;
 };
 
 class TextureCoordinateNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(TextureCoordinateNode)
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
-       bool has_spatial_varying() { return true; }
-       bool has_object_dependency() { return use_transform; }
-
-       float3 normal_osl;
-       bool from_dupli;
-       bool use_transform;
-       Transform ob_tfm;
+ public:
+  SHADER_NODE_CLASS(TextureCoordinateNode)
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  bool has_object_dependency()
+  {
+    return use_transform;
+  }
+
+  float3 normal_osl;
+  bool from_dupli;
+  bool use_transform;
+  Transform ob_tfm;
 };
 
 class UVMapNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(UVMapNode)
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
-       bool has_spatial_varying() { return true; }
-       virtual int get_group() { return NODE_GROUP_LEVEL_1; }
-
-       ustring attribute;
-       bool from_dupli;
+ public:
+  SHADER_NODE_CLASS(UVMapNode)
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_1;
+  }
+
+  ustring attribute;
+  bool from_dupli;
 };
 
 class LightPathNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(LightPathNode)
-       virtual int get_group() { return NODE_GROUP_LEVEL_1; }
+ public:
+  SHADER_NODE_CLASS(LightPathNode)
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_1;
+  }
 };
 
 class LightFalloffNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(LightFalloffNode)
-       bool has_spatial_varying() { return true; }
-       virtual int get_group() { return NODE_GROUP_LEVEL_2; }
+ public:
+  SHADER_NODE_CLASS(LightFalloffNode)
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_2;
+  }
 
-       float strength;
-       float smooth;
+  float strength;
+  float smooth;
 };
 
 class ObjectInfoNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(ObjectInfoNode)
-       virtual int get_group() { return NODE_GROUP_LEVEL_1; }
+ public:
+  SHADER_NODE_CLASS(ObjectInfoNode)
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_1;
+  }
 };
 
 class ParticleInfoNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(ParticleInfoNode)
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
-       virtual int get_group() { return NODE_GROUP_LEVEL_1; }
+ public:
+  SHADER_NODE_CLASS(ParticleInfoNode)
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_1;
+  }
 };
 
 class HairInfoNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(HairInfoNode)
-
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
-       bool has_spatial_varying() { return true; }
-       virtual int get_group() { return NODE_GROUP_LEVEL_1; }
-       virtual int get_feature() {
-               return ShaderNode::get_feature() | NODE_FEATURE_HAIR;
-       }
+ public:
+  SHADER_NODE_CLASS(HairInfoNode)
+
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_1;
+  }
+  virtual int get_feature()
+  {
+    return ShaderNode::get_feature() | NODE_FEATURE_HAIR;
+  }
 };
 
 class ValueNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(ValueNode)
+ public:
+  SHADER_NODE_CLASS(ValueNode)
 
-       void constant_fold(const ConstantFolder& folder);
+  void constant_fold(const ConstantFolder &folder);
 
-       float value;
+  float value;
 };
 
 class ColorNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(ColorNode)
+ public:
+  SHADER_NODE_CLASS(ColorNode)
 
-       void constant_fold(const ConstantFolder& folder);
+  void constant_fold(const ConstantFolder &folder);
 
-       float3 value;
+  float3 value;
 };
 
 class AddClosureNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(AddClosureNode)
-       void constant_fold(const ConstantFolder& folder);
+ public:
+  SHADER_NODE_CLASS(AddClosureNode)
+  void constant_fold(const ConstantFolder &folder);
 };
 
 class MixClosureNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(MixClosureNode)
-       void constant_fold(const ConstantFolder& folder);
+ public:
+  SHADER_NODE_CLASS(MixClosureNode)
+  void constant_fold(const ConstantFolder &folder);
 
-       float fac;
+  float fac;
 };
 
 class MixClosureWeightNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(MixClosureWeightNode)
+ public:
+  SHADER_NODE_CLASS(MixClosureWeightNode)
 
-       float weight;
-       float fac;
+  float weight;
+  float fac;
 };
 
 class InvertNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(InvertNode)
-       void constant_fold(const ConstantFolder& folder);
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
+ public:
+  SHADER_NODE_CLASS(InvertNode)
+  void constant_fold(const ConstantFolder &folder);
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
 
-       float fac;
-       float3 color;
+  float fac;
+  float3 color;
 };
 
 class MixNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(MixNode)
-       void constant_fold(const ConstantFolder& folder);
+ public:
+  SHADER_NODE_CLASS(MixNode)
+  void constant_fold(const ConstantFolder &folder);
 
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
 
-       NodeMix type;
-       bool use_clamp;
-       float3 color1;
-       float3 color2;
-       float fac;
+  NodeMix type;
+  bool use_clamp;
+  float3 color1;
+  float3 color2;
+  float fac;
 };
 
 class CombineRGBNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(CombineRGBNode)
-       void constant_fold(const ConstantFolder& folder);
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
+ public:
+  SHADER_NODE_CLASS(CombineRGBNode)
+  void constant_fold(const ConstantFolder &folder);
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
 
-       float r, g, b;
+  float r, g, b;
 };
 
 class CombineHSVNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(CombineHSVNode)
-       void constant_fold(const ConstantFolder& folder);
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
+ public:
+  SHADER_NODE_CLASS(CombineHSVNode)
+  void constant_fold(const ConstantFolder &folder);
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
 
-       float h, s, v;
+  float h, s, v;
 };
 
 class CombineXYZNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(CombineXYZNode)
-       void constant_fold(const ConstantFolder& folder);
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
+ public:
+  SHADER_NODE_CLASS(CombineXYZNode)
+  void constant_fold(const ConstantFolder &folder);
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
 
-       float x, y, z;
+  float x, y, z;
 };
 
 class GammaNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(GammaNode)
-       void constant_fold(const ConstantFolder& folder);
-       virtual int get_group() { return NODE_GROUP_LEVEL_1; }
+ public:
+  SHADER_NODE_CLASS(GammaNode)
+  void constant_fold(const ConstantFolder &folder);
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_1;
+  }
 
-       float3 color;
-       float gamma;
+  float3 color;
+  float gamma;
 };
 
 class BrightContrastNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(BrightContrastNode)
-       void constant_fold(const ConstantFolder& folder);
-       virtual int get_group() { return NODE_GROUP_LEVEL_1; }
+ public:
+  SHADER_NODE_CLASS(BrightContrastNode)
+  void constant_fold(const ConstantFolder &folder);
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_1;
+  }
 
-       float3 color;
-       float bright;
-       float contrast;
+  float3 color;
+  float bright;
+  float contrast;
 };
 
 class SeparateRGBNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(SeparateRGBNode)
-       void constant_fold(const ConstantFolder& folder);
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
+ public:
+  SHADER_NODE_CLASS(SeparateRGBNode)
+  void constant_fold(const ConstantFolder &folder);
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
 
-       float3 color;
+  float3 color;
 };
 
 class SeparateHSVNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(SeparateHSVNode)
-       void constant_fold(const ConstantFolder& folder);
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
+ public:
+  SHADER_NODE_CLASS(SeparateHSVNode)
+  void constant_fold(const ConstantFolder &folder);
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
 
-       float3 color;
+  float3 color;
 };
 
 class SeparateXYZNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(SeparateXYZNode)
-       void constant_fold(const ConstantFolder& folder);
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
+ public:
+  SHADER_NODE_CLASS(SeparateXYZNode)
+  void constant_fold(const ConstantFolder &folder);
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
 
-       float3 vector;
+  float3 vector;
 };
 
 class HSVNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(HSVNode)
+ public:
+  SHADER_NODE_CLASS(HSVNode)
 
-       float hue;
-       float saturation;
-       float value;
-       float fac;
-       float3 color;
+  float hue;
+  float saturation;
+  float value;
+  float fac;
+  float3 color;
 };
 
 class AttributeNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(AttributeNode)
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
-       bool has_spatial_varying() { return true; }
+ public:
+  SHADER_NODE_CLASS(AttributeNode)
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
+  bool has_spatial_varying()
+  {
+    return true;
+  }
 
-       ustring attribute;
+  ustring attribute;
 };
 
 class CameraNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(CameraNode)
-       bool has_spatial_varying() { return true; }
-       virtual int get_group() { return NODE_GROUP_LEVEL_2; }
+ public:
+  SHADER_NODE_CLASS(CameraNode)
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_2;
+  }
 };
 
 class FresnelNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(FresnelNode)
-       bool has_spatial_varying() { return true; }
-       virtual int get_group() { return NODE_GROUP_LEVEL_1; }
+ public:
+  SHADER_NODE_CLASS(FresnelNode)
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_1;
+  }
 
-       float3 normal;
-       float IOR;
+  float3 normal;
+  float IOR;
 };
 
 class LayerWeightNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(LayerWeightNode)
-       bool has_spatial_varying() { return true; }
-       virtual int get_group() { return NODE_GROUP_LEVEL_1; }
+ public:
+  SHADER_NODE_CLASS(LayerWeightNode)
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_1;
+  }
 
-       float3 normal;
-       float blend;
+  float3 normal;
+  float blend;
 };
 
 class WireframeNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(WireframeNode)
-       bool has_spatial_varying() { return true; }
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
+ public:
+  SHADER_NODE_CLASS(WireframeNode)
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
 
-       float size;
-       bool use_pixel_size;
+  float size;
+  bool use_pixel_size;
 };
 
 class WavelengthNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(WavelengthNode)
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
+ public:
+  SHADER_NODE_CLASS(WavelengthNode)
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
 
-       float wavelength;
+  float wavelength;
 };
 
 class BlackbodyNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(BlackbodyNode)
-       void constant_fold(const ConstantFolder& folder);
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
+ public:
+  SHADER_NODE_CLASS(BlackbodyNode)
+  void constant_fold(const ConstantFolder &folder);
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
 
-       float temperature;
+  float temperature;
 };
 
 class MathNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(MathNode)
-       virtual int get_group() { return NODE_GROUP_LEVEL_1; }
-       void constant_fold(const ConstantFolder& folder);
+ public:
+  SHADER_NODE_CLASS(MathNode)
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_1;
+  }
+  void constant_fold(const ConstantFolder &folder);
 
-       float value1;
-       float value2;
-       NodeMath type;
-       bool use_clamp;
+  float value1;
+  float value2;
+  NodeMath type;
+  bool use_clamp;
 };
 
 class NormalNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(NormalNode)
-       virtual int get_group() { return NODE_GROUP_LEVEL_2; }
+ public:
+  SHADER_NODE_CLASS(NormalNode)
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_2;
+  }
 
-       float3 direction;
-       float3 normal;
+  float3 direction;
+  float3 normal;
 };
 
 class VectorMathNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(VectorMathNode)
-       virtual int get_group() { return NODE_GROUP_LEVEL_1; }
-       void constant_fold(const ConstantFolder& folder);
+ public:
+  SHADER_NODE_CLASS(VectorMathNode)
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_1;
+  }
+  void constant_fold(const ConstantFolder &folder);
 
-       float3 vector1;
-       float3 vector2;
-       NodeVectorMath type;
+  float3 vector1;
+  float3 vector2;
+  NodeVectorMath type;
 };
 
 class VectorTransformNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(VectorTransformNode)
+ public:
+  SHADER_NODE_CLASS(VectorTransformNode)
 
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
 
-       NodeVectorTransformType type;
-       NodeVectorTransformConvertSpace convert_from;
-       NodeVectorTransformConvertSpace convert_to;
-       float3 vector;
+  NodeVectorTransformType type;
+  NodeVectorTransformConvertSpace convert_from;
+  NodeVectorTransformConvertSpace convert_to;
+  float3 vector;
 };
 
 class BumpNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(BumpNode)
-       void constant_fold(const ConstantFolder& folder);
-       bool has_spatial_varying() { return true; }
-       virtual int get_feature() {
-               return NODE_FEATURE_BUMP;
-       }
-
-       bool invert;
-       bool use_object_space;
-       float height;
-       float sample_center;
-       float sample_x;
-       float sample_y;
-       float3 normal;
-       float strength;
-       float distance;
+ public:
+  SHADER_NODE_CLASS(BumpNode)
+  void constant_fold(const ConstantFolder &folder);
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  virtual int get_feature()
+  {
+    return NODE_FEATURE_BUMP;
+  }
+
+  bool invert;
+  bool use_object_space;
+  float height;
+  float sample_center;
+  float sample_x;
+  float sample_y;
+  float3 normal;
+  float strength;
+  float distance;
 };
 
 class CurvesNode : public ShaderNode {
-public:
-       explicit CurvesNode(const NodeType *node_type);
-       SHADER_NODE_BASE_CLASS(CurvesNode)
+ public:
+  explicit CurvesNode(const NodeType *node_type);
+  SHADER_NODE_BASE_CLASS(CurvesNode)
 
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
 
-       array<float3> curves;
-       float min_x, max_x, fac;
-       float3 value;
+  array<float3> curves;
+  float min_x, max_x, fac;
+  float3 value;
 
-protected:
-       using ShaderNode::constant_fold;
-       void constant_fold(const ConstantFolder& folder, ShaderInput *value_in);
-       void compile(SVMCompiler& compiler, int type, ShaderInput *value_in, ShaderOutput *value_out);
-       void compile(OSLCompiler& compiler, const char *name);
+ protected:
+  using ShaderNode::constant_fold;
+  void constant_fold(const ConstantFolder &folder, ShaderInput *value_in);
+  void compile(SVMCompiler &compiler, int type, ShaderInput *value_in, ShaderOutput *value_out);
+  void compile(OSLCompiler &compiler, const char *name);
 };
 
 class RGBCurvesNode : public CurvesNode {
-public:
-       SHADER_NODE_CLASS(RGBCurvesNode)
-       void constant_fold(const ConstantFolder& folder);
+ public:
+  SHADER_NODE_CLASS(RGBCurvesNode)
+  void constant_fold(const ConstantFolder &folder);
 };
 
 class VectorCurvesNode : public CurvesNode {
-public:
-       SHADER_NODE_CLASS(VectorCurvesNode)
-       void constant_fold(const ConstantFolder& folder);
+ public:
+  SHADER_NODE_CLASS(VectorCurvesNode)
+  void constant_fold(const ConstantFolder &folder);
 };
 
 class RGBRampNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(RGBRampNode)
-       void constant_fold(const ConstantFolder& folder);
-       virtual int get_group() { return NODE_GROUP_LEVEL_1; }
+ public:
+  SHADER_NODE_CLASS(RGBRampNode)
+  void constant_fold(const ConstantFolder &folder);
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_1;
+  }
 
-       array<float3> ramp;
-       array<float> ramp_alpha;
-       float fac;
-       bool interpolate;
+  array<float3> ramp;
+  array<float> ramp_alpha;
+  float fac;
+  bool interpolate;
 };
 
 class SetNormalNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(SetNormalNode)
-       float3 direction;
+ public:
+  SHADER_NODE_CLASS(SetNormalNode)
+  float3 direction;
 };
 
 class OSLNode : public ShaderNode {
-public:
-       static OSLNode *create(size_t num_inputs, const OSLNode *from = NULL);
-       ~OSLNode();
+ public:
+  static OSLNode *create(size_t num_inputs, const OSLNode *from = NULL);
+  ~OSLNode();
 
-       ShaderNode *clone() const;
+  ShaderNode *clone() const;
 
-       char* input_default_value();
-       void add_input(ustring name, SocketType::Type type);
-       void add_output(ustring name, SocketType::Type type);
+  char *input_default_value();
+  void add_input(ustring name, SocketType::Type type);
+  void add_output(ustring name, SocketType::Type type);
 
-       SHADER_NODE_NO_CLONE_CLASS(OSLNode)
+  SHADER_NODE_NO_CLONE_CLASS(OSLNode)
 
-       /* ideally we could beter detect this, but we can't query this now */
-       bool has_spatial_varying() { return true; }
-       bool has_volume_support() { return true; }
+  /* ideally we could beter detect this, but we can't query this now */
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  bool has_volume_support()
+  {
+    return true;
+  }
 
-       virtual bool equals(const ShaderNode& /*other*/) { return false; }
+  virtual bool equals(const ShaderNode & /*other*/)
+  {
+    return false;
+  }
 
-       string filepath;
-       string bytecode_hash;
+  string filepath;
+  string bytecode_hash;
 };
 
 class NormalMapNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(NormalMapNode)
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
-       bool has_spatial_varying() { return true; }
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
-
-       NodeNormalMapSpace space;
-       ustring attribute;
-       float strength;
-       float3 color;
-       float3 normal_osl;
+ public:
+  SHADER_NODE_CLASS(NormalMapNode)
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
+
+  NodeNormalMapSpace space;
+  ustring attribute;
+  float strength;
+  float3 color;
+  float3 normal_osl;
 };
 
 class TangentNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(TangentNode)
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
-       bool has_spatial_varying() { return true; }
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
-
-       NodeTangentDirectionType direction_type;
-       NodeTangentAxis axis;
-       ustring attribute;
-       float3 normal_osl;
+ public:
+  SHADER_NODE_CLASS(TangentNode)
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
+
+  NodeTangentDirectionType direction_type;
+  NodeTangentAxis axis;
+  ustring attribute;
+  float3 normal_osl;
 };
 
 class BevelNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(BevelNode)
-       bool has_spatial_varying() { return true; }
-       virtual int get_group() { return NODE_GROUP_LEVEL_3; }
-       virtual bool has_raytrace() { return true; }
-
-       float radius;
-       float3 normal;
-       int samples;
+ public:
+  SHADER_NODE_CLASS(BevelNode)
+  bool has_spatial_varying()
+  {
+    return true;
+  }
+  virtual int get_group()
+  {
+    return NODE_GROUP_LEVEL_3;
+  }
+  virtual bool has_raytrace()
+  {
+    return true;
+  }
+
+  float radius;
+  float3 normal;
+  int samples;
 };
 
 class DisplacementNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(DisplacementNode)
-       void constant_fold(const ConstantFolder& folder);
-       virtual int get_feature() {
-               return NODE_FEATURE_BUMP;
-       }
+ public:
+  SHADER_NODE_CLASS(DisplacementNode)
+  void constant_fold(const ConstantFolder &folder);
+  virtual int get_feature()
+  {
+    return NODE_FEATURE_BUMP;
+  }
 
-       NodeNormalMapSpace space;
-       float height;
-       float midlevel;
-       float scale;
-       float3 normal;
+  NodeNormalMapSpace space;
+  float height;
+  float midlevel;
+  float scale;
+  float3 normal;
 };
 
 class VectorDisplacementNode : public ShaderNode {
-public:
-       SHADER_NODE_CLASS(VectorDisplacementNode)
-       void attributes(Shader *shader, AttributeRequestSet *attributes);
-       bool has_attribute_dependency() { return true; }
-       void constant_fold(const ConstantFolder& folder);
-       virtual int get_feature() {
-               return NODE_FEATURE_BUMP;
-       }
-
-       NodeNormalMapSpace space;
-       ustring attribute;
-       float3 vector;
-       float midlevel;
-       float scale;
+ public:
+  SHADER_NODE_CLASS(VectorDisplacementNode)
+  void attributes(Shader *shader, AttributeRequestSet *attributes);
+  bool has_attribute_dependency()
+  {
+    return true;
+  }
+  void constant_fold(const ConstantFolder &folder);
+  virtual int get_feature()
+  {
+    return NODE_FEATURE_BUMP;
+  }
+
+  NodeNormalMapSpace space;
+  ustring attribute;
+  float3 vector;
+  float midlevel;
+  float scale;
 };
 
 CCL_NAMESPACE_END
 
-#endif  /* __NODES_H__ */
+#endif /* __NODES_H__ */