Revert "Cycles API: encapsulate Node socket members"

This reverts commit 527f8b32b32187f754e5b176db6377736f9cb8ff. It is causing
motion blur test failures and crashes in some renders, reverting until this is
fixed.

1 files changed, 70 insertions, 77 deletions

diff --git a/intern/cycles/render/nodes.cpp b/intern/cycles/render/nodes.cpp
index 546206f593b..fc525e06d1e 100644
--- a/intern/cycles/render/nodes.cpp
+++ b/intern/cycles/render/nodes.cpp
@@ -247,9 +247,6 @@ NODE_DEFINE(ImageTextureNode)
 
   SOCKET_FLOAT(projection_blend, "Projection Blend", 0.0f);
 
-  SOCKET_INT_ARRAY(tiles, "Tiles", array<int>());
-  SOCKET_BOOLEAN(animated, "Animated", false);
-
   SOCKET_IN_POINT(vector, "Vector", make_float3(0.0f, 0.0f, 0.0f), SocketType::LINK_TEXTURE_UV);
 
   SOCKET_OUT_COLOR(color, "Color");
@@ -262,7 +259,7 @@ ImageTextureNode::ImageTextureNode() : ImageSlotTextureNode(node_type)
 {
   colorspace = u_colorspace_raw;
   animated = false;
-  tiles.push_back_slow(1001);
+  tiles.push_back(1001);
 }
 
 ShaderNode *ImageTextureNode::clone(ShaderGraph *graph) const
@@ -289,7 +286,7 @@ void ImageTextureNode::cull_tiles(Scene *scene, ShaderGraph *graph)
    * 1001 tile, so there's no point in loading any others. */
   if (projection == NODE_IMAGE_PROJ_BOX) {
     tiles.clear();
-    tiles.push_back_slow(1001);
+    tiles.push_back(1001);
     return;
   }
 
@@ -311,7 +308,7 @@ void ImageTextureNode::cull_tiles(Scene *scene, ShaderGraph *graph)
     ShaderNode *node = vector_in->link->parent;
     if (node->type == UVMapNode::node_type) {
       UVMapNode *uvmap = (UVMapNode *)node;
-      attribute = uvmap->get_attribute();
+      attribute = uvmap->attribute;
     }
     else if (node->type == TextureCoordinateNode::node_type) {
       if (vector_in->link != node->output("UV")) {
@@ -328,21 +325,20 @@ void ImageTextureNode::cull_tiles(Scene *scene, ShaderGraph *graph)
    * be to have a cache in each mesh that is indexed by attribute.
    * Additionally, building a graph-to-meshes list once could help. */
   foreach (Geometry *geom, scene->geometry) {
-    foreach (Node *node, geom->get_used_shaders()) {
-      Shader *shader = static_cast<Shader *>(node);
+    foreach (Shader *shader, geom->used_shaders) {
       if (shader->graph == graph) {
         geom->get_uv_tiles(attribute, used_tiles);
       }
     }
   }
 
-  array<int> new_tiles;
+  ccl::vector<int> new_tiles;
   foreach (int tile, tiles) {
     if (used_tiles.count(tile)) {
-      new_tiles.push_back_slow(tile);
+      new_tiles.push_back(tile);
     }
   }
-  tiles.steal_data(new_tiles);
+  tiles.swap(new_tiles);
 }
 
 void ImageTextureNode::attributes(Shader *shader, AttributeRequestSet *attributes)
@@ -515,8 +511,6 @@ NODE_DEFINE(EnvironmentTextureNode)
   projection_enum.insert("mirror_ball", NODE_ENVIRONMENT_MIRROR_BALL);
   SOCKET_ENUM(projection, "Projection", projection_enum, NODE_ENVIRONMENT_EQUIRECTANGULAR);
 
-  SOCKET_BOOLEAN(animated, "Animated", false);
-
   SOCKET_IN_POINT(vector, "Vector", make_float3(0.0f, 0.0f, 0.0f), SocketType::LINK_POSITION);
 
   SOCKET_OUT_COLOR(color, "Color");
@@ -796,7 +790,7 @@ NODE_DEFINE(SkyTextureNode)
   type_enum.insert("preetham", NODE_SKY_PREETHAM);
   type_enum.insert("hosek_wilkie", NODE_SKY_HOSEK);
   type_enum.insert("nishita_improved", NODE_SKY_NISHITA);
-  SOCKET_ENUM(sky_type, "Type", type_enum, NODE_SKY_NISHITA);
+  SOCKET_ENUM(type, "Type", type_enum, NODE_SKY_NISHITA);
 
   SOCKET_VECTOR(sun_direction, "Sun Direction", make_float3(0.0f, 0.0f, 1.0f));
   SOCKET_FLOAT(turbidity, "Turbidity", 2.2f);
@@ -829,11 +823,11 @@ void SkyTextureNode::compile(SVMCompiler &compiler)
   ShaderOutput *color_out = output("Color");
 
   SunSky sunsky;
-  if (sky_type == NODE_SKY_PREETHAM)
+  if (type == NODE_SKY_PREETHAM)
     sky_texture_precompute_preetham(&sunsky, sun_direction, turbidity);
-  else if (sky_type == NODE_SKY_HOSEK)
+  else if (type == NODE_SKY_HOSEK)
     sky_texture_precompute_hosek(&sunsky, sun_direction, turbidity, ground_albedo);
-  else if (sky_type == NODE_SKY_NISHITA) {
+  else if (type == NODE_SKY_NISHITA) {
     /* Clamp altitude to reasonable values.
      * Below 1m causes numerical issues and above 60km is space. */
     float clamped_altitude = clamp(altitude, 1.0f, 59999.0f);
@@ -866,9 +860,9 @@ void SkyTextureNode::compile(SVMCompiler &compiler)
   int vector_offset = tex_mapping.compile_begin(compiler, vector_in);
 
   compiler.stack_assign(color_out);
-  compiler.add_node(NODE_TEX_SKY, vector_offset, compiler.stack_assign(color_out), sky_type);
+  compiler.add_node(NODE_TEX_SKY, vector_offset, compiler.stack_assign(color_out), type);
   /* nishita doesn't need this data */
-  if (sky_type != NODE_SKY_NISHITA) {
+  if (type != NODE_SKY_NISHITA) {
     compiler.add_node(__float_as_uint(sunsky.phi),
                       __float_as_uint(sunsky.theta),
                       __float_as_uint(sunsky.radiance_x),
@@ -925,11 +919,11 @@ void SkyTextureNode::compile(OSLCompiler &compiler)
   tex_mapping.compile(compiler);
 
   SunSky sunsky;
-  if (sky_type == NODE_SKY_PREETHAM)
+  if (type == NODE_SKY_PREETHAM)
     sky_texture_precompute_preetham(&sunsky, sun_direction, turbidity);
-  else if (sky_type == NODE_SKY_HOSEK)
+  else if (type == NODE_SKY_HOSEK)
     sky_texture_precompute_hosek(&sunsky, sun_direction, turbidity, ground_albedo);
-  else if (sky_type == NODE_SKY_NISHITA) {
+  else if (type == NODE_SKY_NISHITA) {
     /* Clamp altitude to reasonable values.
      * Below 1m causes numerical issues and above 60km is space. */
     float clamped_altitude = clamp(altitude, 1.0f, 59999.0f);
@@ -969,7 +963,7 @@ void SkyTextureNode::compile(OSLCompiler &compiler)
   compiler.parameter_array("config_z", sunsky.config_z, 9);
   compiler.parameter_array("nishita_data", sunsky.nishita_data, 10);
   /* nishita texture */
-  if (sky_type == NODE_SKY_NISHITA) {
+  if (type == NODE_SKY_NISHITA) {
     compiler.parameter_texture("filename", handle.svm_slot());
   }
   compiler.add(this, "node_sky_texture");
@@ -991,7 +985,7 @@ NODE_DEFINE(GradientTextureNode)
   type_enum.insert("radial", NODE_BLEND_RADIAL);
   type_enum.insert("quadratic_sphere", NODE_BLEND_QUADRATIC_SPHERE);
   type_enum.insert("spherical", NODE_BLEND_SPHERICAL);
-  SOCKET_ENUM(gradient_type, "Type", type_enum, NODE_BLEND_LINEAR);
+  SOCKET_ENUM(type, "Type", type_enum, NODE_BLEND_LINEAR);
 
   SOCKET_IN_POINT(
       vector, "Vector", make_float3(0.0f, 0.0f, 0.0f), SocketType::LINK_TEXTURE_GENERATED);
@@ -1015,7 +1009,7 @@ void GradientTextureNode::compile(SVMCompiler &compiler)
   int vector_offset = tex_mapping.compile_begin(compiler, vector_in);
 
   compiler.add_node(NODE_TEX_GRADIENT,
-                    compiler.encode_uchar4(gradient_type,
+                    compiler.encode_uchar4(type,
                                            vector_offset,
                                            compiler.stack_assign_if_linked(fac_out),
                                            compiler.stack_assign_if_linked(color_out)));
@@ -1375,7 +1369,7 @@ NODE_DEFINE(MusgraveTextureNode)
   type_enum.insert("hybrid_multifractal", NODE_MUSGRAVE_HYBRID_MULTIFRACTAL);
   type_enum.insert("ridged_multifractal", NODE_MUSGRAVE_RIDGED_MULTIFRACTAL);
   type_enum.insert("hetero_terrain", NODE_MUSGRAVE_HETERO_TERRAIN);
-  SOCKET_ENUM(musgrave_type, "Type", type_enum, NODE_MUSGRAVE_FBM);
+  SOCKET_ENUM(type, "Type", type_enum, NODE_MUSGRAVE_FBM);
 
   SOCKET_IN_POINT(
       vector, "Vector", make_float3(0.0f, 0.0f, 0.0f), SocketType::LINK_TEXTURE_GENERATED);
@@ -1420,7 +1414,7 @@ void MusgraveTextureNode::compile(SVMCompiler &compiler)
 
   compiler.add_node(
       NODE_TEX_MUSGRAVE,
-      compiler.encode_uchar4(musgrave_type, dimensions, vector_stack_offset, w_stack_offset),
+      compiler.encode_uchar4(type, dimensions, vector_stack_offset, w_stack_offset),
       compiler.encode_uchar4(scale_stack_offset,
                              detail_stack_offset,
                              dimension_stack_offset,
@@ -1453,7 +1447,7 @@ NODE_DEFINE(WaveTextureNode)
   static NodeEnum type_enum;
   type_enum.insert("bands", NODE_WAVE_BANDS);
   type_enum.insert("rings", NODE_WAVE_RINGS);
-  SOCKET_ENUM(wave_type, "Type", type_enum, NODE_WAVE_BANDS);
+  SOCKET_ENUM(type, "Type", type_enum, NODE_WAVE_BANDS);
 
   static NodeEnum bands_direction_enum;
   bands_direction_enum.insert("x", NODE_WAVE_BANDS_DIRECTION_X);
@@ -1510,7 +1504,7 @@ void WaveTextureNode::compile(SVMCompiler &compiler)
   int vector_offset = tex_mapping.compile_begin(compiler, vector_in);
 
   compiler.add_node(NODE_TEX_WAVE,
-                    compiler.encode_uchar4(wave_type, bands_direction, rings_direction, profile),
+                    compiler.encode_uchar4(type, bands_direction, rings_direction, profile),
                     compiler.encode_uchar4(vector_offset,
                                            compiler.stack_assign_if_linked(scale_in),
                                            compiler.stack_assign_if_linked(distortion_in)),
@@ -1932,7 +1926,7 @@ NODE_DEFINE(MappingNode)
   type_enum.insert("texture", NODE_MAPPING_TYPE_TEXTURE);
   type_enum.insert("vector", NODE_MAPPING_TYPE_VECTOR);
   type_enum.insert("normal", NODE_MAPPING_TYPE_NORMAL);
-  SOCKET_ENUM(mapping_type, "Type", type_enum, NODE_MAPPING_TYPE_POINT);
+  SOCKET_ENUM(type, "Type", type_enum, NODE_MAPPING_TYPE_POINT);
 
   SOCKET_IN_POINT(vector, "Vector", make_float3(0.0f, 0.0f, 0.0f));
   SOCKET_IN_POINT(location, "Location", make_float3(0.0f, 0.0f, 0.0f));
@@ -1951,11 +1945,11 @@ MappingNode::MappingNode() : ShaderNode(node_type)
 void MappingNode::constant_fold(const ConstantFolder &folder)
 {
   if (folder.all_inputs_constant()) {
-    float3 result = svm_mapping((NodeMappingType)mapping_type, vector, location, rotation, scale);
+    float3 result = svm_mapping((NodeMappingType)type, vector, location, rotation, scale);
     folder.make_constant(result);
   }
   else {
-    folder.fold_mapping((NodeMappingType)mapping_type);
+    folder.fold_mapping((NodeMappingType)type);
   }
 }
 
@@ -1975,7 +1969,7 @@ void MappingNode::compile(SVMCompiler &compiler)
 
   compiler.add_node(
       NODE_MAPPING,
-      mapping_type,
+      type,
       compiler.encode_uchar4(
           vector_stack_offset, location_stack_offset, rotation_stack_offset, scale_stack_offset),
       result_stack_offset);
@@ -2391,7 +2385,7 @@ void GlossyBsdfNode::simplify_settings(Scene *scene)
   }
   Integrator *integrator = scene->integrator;
   ShaderInput *roughness_input = input("Roughness");
-  if (integrator->get_filter_glossy() == 0.0f) {
+  if (integrator->filter_glossy == 0.0f) {
     /* Fallback to Sharp closure for Roughness close to 0.
      * Note: Keep the epsilon in sync with kernel!
      */
@@ -2484,7 +2478,7 @@ void GlassBsdfNode::simplify_settings(Scene *scene)
   }
   Integrator *integrator = scene->integrator;
   ShaderInput *roughness_input = input("Roughness");
-  if (integrator->get_filter_glossy() == 0.0f) {
+  if (integrator->filter_glossy == 0.0f) {
     /* Fallback to Sharp closure for Roughness close to 0.
      * Note: Keep the epsilon in sync with kernel!
      */
@@ -2577,7 +2571,7 @@ void RefractionBsdfNode::simplify_settings(Scene *scene)
   }
   Integrator *integrator = scene->integrator;
   ShaderInput *roughness_input = input("Roughness");
-  if (integrator->get_filter_glossy() == 0.0f) {
+  if (integrator->filter_glossy == 0.0f) {
     /* Fallback to Sharp closure for Roughness close to 0.
      * Note: Keep the epsilon in sync with kernel!
      */
@@ -4485,7 +4479,7 @@ void VolumeInfoNode::expand(ShaderGraph *graph)
   ShaderOutput *color_out = output("Color");
   if (!color_out->links.empty()) {
     AttributeNode *attr = graph->create_node<AttributeNode>();
-    attr->set_attribute(ustring("color"));
+    attr->attribute = "color";
     graph->add(attr);
     graph->relink(color_out, attr->output("Color"));
   }
@@ -4493,7 +4487,7 @@ void VolumeInfoNode::expand(ShaderGraph *graph)
   ShaderOutput *density_out = output("Density");
   if (!density_out->links.empty()) {
     AttributeNode *attr = graph->create_node<AttributeNode>();
-    attr->set_attribute(ustring("density"));
+    attr->attribute = "density";
     graph->add(attr);
     graph->relink(density_out, attr->output("Fac"));
   }
@@ -4501,7 +4495,7 @@ void VolumeInfoNode::expand(ShaderGraph *graph)
   ShaderOutput *flame_out = output("Flame");
   if (!flame_out->links.empty()) {
     AttributeNode *attr = graph->create_node<AttributeNode>();
-    attr->set_attribute(ustring("flame"));
+    attr->attribute = "flame";
     graph->add(attr);
     graph->relink(flame_out, attr->output("Fac"));
   }
@@ -4509,7 +4503,7 @@ void VolumeInfoNode::expand(ShaderGraph *graph)
   ShaderOutput *temperature_out = output("Temperature");
   if (!temperature_out->links.empty()) {
     AttributeNode *attr = graph->create_node<AttributeNode>();
-    attr->set_attribute(ustring("temperature"));
+    attr->attribute = "temperature";
     graph->add(attr);
     graph->relink(temperature_out, attr->output("Fac"));
   }
@@ -4886,7 +4880,7 @@ NODE_DEFINE(MixNode)
   type_enum.insert("color", NODE_MIX_COLOR);
   type_enum.insert("soft_light", NODE_MIX_SOFT);
   type_enum.insert("linear_light", NODE_MIX_LINEAR);
-  SOCKET_ENUM(mix_type, "Type", type_enum, NODE_MIX_BLEND);
+  SOCKET_ENUM(type, "Type", type_enum, NODE_MIX_BLEND);
 
   SOCKET_BOOLEAN(use_clamp, "Use Clamp", false);
 
@@ -4914,7 +4908,7 @@ void MixNode::compile(SVMCompiler &compiler)
                     compiler.stack_assign(fac_in),
                     compiler.stack_assign(color1_in),
                     compiler.stack_assign(color2_in));
-  compiler.add_node(NODE_MIX, mix_type, compiler.stack_assign(color_out));
+  compiler.add_node(NODE_MIX, type, compiler.stack_assign(color_out));
 
   if (use_clamp) {
     compiler.add_node(NODE_MIX, 0, compiler.stack_assign(color_out));
@@ -4932,10 +4926,10 @@ void MixNode::compile(OSLCompiler &compiler)
 void MixNode::constant_fold(const ConstantFolder &folder)
 {
   if (folder.all_inputs_constant()) {
-    folder.make_constant_clamp(svm_mix(mix_type, fac, color1, color2), use_clamp);
+    folder.make_constant_clamp(svm_mix(type, fac, color1, color2), use_clamp);
   }
   else {
-    folder.fold_mix(mix_type, use_clamp);
+    folder.fold_mix(type, use_clamp);
   }
 }
 
@@ -5754,7 +5748,7 @@ NODE_DEFINE(MapRangeNode)
   type_enum.insert("stepped", NODE_MAP_RANGE_STEPPED);
   type_enum.insert("smoothstep", NODE_MAP_RANGE_SMOOTHSTEP);
   type_enum.insert("smootherstep", NODE_MAP_RANGE_SMOOTHERSTEP);
-  SOCKET_ENUM(range_type, "Type", type_enum, NODE_MAP_RANGE_LINEAR);
+  SOCKET_ENUM(type, "Type", type_enum, NODE_MAP_RANGE_LINEAR);
 
   SOCKET_IN_FLOAT(value, "Value", 1.0f);
   SOCKET_IN_FLOAT(from_min, "From Min", 0.0f);
@@ -5778,7 +5772,7 @@ void MapRangeNode::expand(ShaderGraph *graph)
     ShaderOutput *result_out = output("Result");
     if (!result_out->links.empty()) {
       ClampNode *clamp_node = graph->create_node<ClampNode>();
-      clamp_node->set_clamp_type(NODE_CLAMP_RANGE);
+      clamp_node->type = NODE_CLAMP_RANGE;
       graph->add(clamp_node);
       graph->relink(result_out, clamp_node->output("Result"));
       graph->connect(result_out, clamp_node->input("Value"));
@@ -5786,13 +5780,13 @@ void MapRangeNode::expand(ShaderGraph *graph)
         graph->connect(input("To Min")->link, clamp_node->input("Min"));
       }
       else {
-        clamp_node->set_min(to_min);
+        clamp_node->min = to_min;
       }
       if (input("To Max")->link) {
         graph->connect(input("To Max")->link, clamp_node->input("Max"));
       }
       else {
-        clamp_node->set_max(to_max);
+        clamp_node->max = to_max;
       }
     }
   }
@@ -5821,7 +5815,7 @@ void MapRangeNode::compile(SVMCompiler &compiler)
       value_stack_offset,
       compiler.encode_uchar4(
           from_min_stack_offset, from_max_stack_offset, to_min_stack_offset, to_max_stack_offset),
-      compiler.encode_uchar4(range_type, steps_stack_offset, result_stack_offset));
+      compiler.encode_uchar4(type, steps_stack_offset, result_stack_offset));
 
   compiler.add_node(__float_as_int(from_min),
                     __float_as_int(from_max),
@@ -5845,7 +5839,7 @@ NODE_DEFINE(ClampNode)
   static NodeEnum type_enum;
   type_enum.insert("minmax", NODE_CLAMP_MINMAX);
   type_enum.insert("range", NODE_CLAMP_RANGE);
-  SOCKET_ENUM(clamp_type, "Type", type_enum, NODE_CLAMP_MINMAX);
+  SOCKET_ENUM(type, "Type", type_enum, NODE_CLAMP_MINMAX);
 
   SOCKET_IN_FLOAT(value, "Value", 1.0f);
   SOCKET_IN_FLOAT(min, "Min", 0.0f);
@@ -5863,7 +5857,7 @@ ClampNode::ClampNode() : ShaderNode(node_type)
 void ClampNode::constant_fold(const ConstantFolder &folder)
 {
   if (folder.all_inputs_constant()) {
-    if (clamp_type == NODE_CLAMP_RANGE && (min > max)) {
+    if (type == NODE_CLAMP_RANGE && (min > max)) {
       folder.make_constant(clamp(value, max, min));
     }
     else {
@@ -5886,7 +5880,7 @@ void ClampNode::compile(SVMCompiler &compiler)
 
   compiler.add_node(NODE_CLAMP,
                     value_stack_offset,
-                    compiler.encode_uchar4(min_stack_offset, max_stack_offset, clamp_type),
+                    compiler.encode_uchar4(min_stack_offset, max_stack_offset, type),
                     result_stack_offset);
   compiler.add_node(__float_as_int(min), __float_as_int(max));
 }
@@ -5996,7 +5990,7 @@ NODE_DEFINE(MathNode)
   type_enum.insert("smoothmin", NODE_MATH_SMOOTH_MIN);
   type_enum.insert("smoothmax", NODE_MATH_SMOOTH_MAX);
   type_enum.insert("compare", NODE_MATH_COMPARE);
-  SOCKET_ENUM(math_type, "Type", type_enum, NODE_MATH_ADD);
+  SOCKET_ENUM(type, "Type", type_enum, NODE_MATH_ADD);
 
   SOCKET_BOOLEAN(use_clamp, "Use Clamp", false);
 
@@ -6019,9 +6013,9 @@ void MathNode::expand(ShaderGraph *graph)
     ShaderOutput *result_out = output("Value");
     if (!result_out->links.empty()) {
       ClampNode *clamp_node = graph->create_node<ClampNode>();
-      clamp_node->set_clamp_type(NODE_CLAMP_MINMAX);
-      clamp_node->set_min(0.0f);
-      clamp_node->set_max(1.0f);
+      clamp_node->type = NODE_CLAMP_MINMAX;
+      clamp_node->min = 0.0f;
+      clamp_node->max = 1.0f;
       graph->add(clamp_node);
       graph->relink(result_out, clamp_node->output("Result"));
       graph->connect(result_out, clamp_node->input("Value"));
@@ -6032,10 +6026,10 @@ void MathNode::expand(ShaderGraph *graph)
 void MathNode::constant_fold(const ConstantFolder &folder)
 {
   if (folder.all_inputs_constant()) {
-    folder.make_constant(svm_math(math_type, value1, value2, value3));
+    folder.make_constant(svm_math(type, value1, value2, value3));
   }
   else {
-    folder.fold_math(math_type);
+    folder.fold_math(type);
   }
 }
 
@@ -6053,7 +6047,7 @@ void MathNode::compile(SVMCompiler &compiler)
 
   compiler.add_node(
       NODE_MATH,
-      math_type,
+      type,
       compiler.encode_uchar4(value1_stack_offset, value2_stack_offset, value3_stack_offset),
       value_stack_offset);
 }
@@ -6099,7 +6093,7 @@ NODE_DEFINE(VectorMathNode)
   type_enum.insert("sine", NODE_VECTOR_MATH_SINE);
   type_enum.insert("cosine", NODE_VECTOR_MATH_COSINE);
   type_enum.insert("tangent", NODE_VECTOR_MATH_TANGENT);
-  SOCKET_ENUM(math_type, "Type", type_enum, NODE_VECTOR_MATH_ADD);
+  SOCKET_ENUM(type, "Type", type_enum, NODE_VECTOR_MATH_ADD);
 
   SOCKET_IN_VECTOR(vector1, "Vector1", make_float3(0.0f, 0.0f, 0.0f));
   SOCKET_IN_VECTOR(vector2, "Vector2", make_float3(0.0f, 0.0f, 0.0f));
@@ -6122,7 +6116,7 @@ void VectorMathNode::constant_fold(const ConstantFolder &folder)
   float3 vector = make_float3(0.0f, 0.0f, 0.0f);
 
   if (folder.all_inputs_constant()) {
-    svm_vector_math(&value, &vector, math_type, vector1, vector2, vector3, scale);
+    svm_vector_math(&value, &vector, type, vector1, vector2, vector3, scale);
     if (folder.output == output("Value")) {
       folder.make_constant(value);
     }
@@ -6131,7 +6125,7 @@ void VectorMathNode::constant_fold(const ConstantFolder &folder)
     }
   }
   else {
-    folder.fold_vector_math(math_type);
+    folder.fold_vector_math(type);
   }
 }
 
@@ -6150,12 +6144,12 @@ void VectorMathNode::compile(SVMCompiler &compiler)
   int vector_stack_offset = compiler.stack_assign_if_linked(vector_out);
 
   /* 3 Vector Operators */
-  if (math_type == NODE_VECTOR_MATH_WRAP) {
+  if (type == NODE_VECTOR_MATH_WRAP) {
     ShaderInput *vector3_in = input("Vector3");
     int vector3_stack_offset = compiler.stack_assign(vector3_in);
     compiler.add_node(
         NODE_VECTOR_MATH,
-        math_type,
+        type,
         compiler.encode_uchar4(vector1_stack_offset, vector2_stack_offset, scale_stack_offset),
         compiler.encode_uchar4(value_stack_offset, vector_stack_offset));
     compiler.add_node(vector3_stack_offset);
@@ -6163,7 +6157,7 @@ void VectorMathNode::compile(SVMCompiler &compiler)
   else {
     compiler.add_node(
         NODE_VECTOR_MATH,
-        math_type,
+        type,
         compiler.encode_uchar4(vector1_stack_offset, vector2_stack_offset, scale_stack_offset),
         compiler.encode_uchar4(value_stack_offset, vector_stack_offset));
   }
@@ -6187,7 +6181,7 @@ NODE_DEFINE(VectorRotateNode)
   type_enum.insert("y_axis", NODE_VECTOR_ROTATE_TYPE_AXIS_Y);
   type_enum.insert("z_axis", NODE_VECTOR_ROTATE_TYPE_AXIS_Z);
   type_enum.insert("euler_xyz", NODE_VECTOR_ROTATE_TYPE_EULER_XYZ);
-  SOCKET_ENUM(rotate_type, "Type", type_enum, NODE_VECTOR_ROTATE_TYPE_AXIS);
+  SOCKET_ENUM(type, "Type", type_enum, NODE_VECTOR_ROTATE_TYPE_AXIS);
 
   SOCKET_BOOLEAN(invert, "Invert", false);
 
@@ -6214,15 +6208,14 @@ void VectorRotateNode::compile(SVMCompiler &compiler)
   ShaderInput *angle_in = input("Angle");
   ShaderOutput *vector_out = output("Vector");
 
-  compiler.add_node(NODE_VECTOR_ROTATE,
-                    compiler.encode_uchar4(rotate_type,
-                                           compiler.stack_assign(vector_in),
-                                           compiler.stack_assign(rotation_in),
-                                           invert),
-                    compiler.encode_uchar4(compiler.stack_assign(center_in),
-                                           compiler.stack_assign(axis_in),
-                                           compiler.stack_assign(angle_in)),
-                    compiler.stack_assign(vector_out));
+  compiler.add_node(
+      NODE_VECTOR_ROTATE,
+      compiler.encode_uchar4(
+          type, compiler.stack_assign(vector_in), compiler.stack_assign(rotation_in), invert),
+      compiler.encode_uchar4(compiler.stack_assign(center_in),
+                             compiler.stack_assign(axis_in),
+                             compiler.stack_assign(angle_in)),
+      compiler.stack_assign(vector_out));
 }
 
 void VectorRotateNode::compile(OSLCompiler &compiler)
@@ -6242,7 +6235,7 @@ NODE_DEFINE(VectorTransformNode)
   type_enum.insert("vector", NODE_VECTOR_TRANSFORM_TYPE_VECTOR);
   type_enum.insert("point", NODE_VECTOR_TRANSFORM_TYPE_POINT);
   type_enum.insert("normal", NODE_VECTOR_TRANSFORM_TYPE_NORMAL);
-  SOCKET_ENUM(transform_type, "Type", type_enum, NODE_VECTOR_TRANSFORM_TYPE_VECTOR);
+  SOCKET_ENUM(type, "Type", type_enum, NODE_VECTOR_TRANSFORM_TYPE_VECTOR);
 
   static NodeEnum space_enum;
   space_enum.insert("world", NODE_VECTOR_TRANSFORM_CONVERT_SPACE_WORLD);
@@ -6268,7 +6261,7 @@ void VectorTransformNode::compile(SVMCompiler &compiler)
 
   compiler.add_node(
       NODE_VECTOR_TRANSFORM,
-      compiler.encode_uchar4(transform_type, convert_from, convert_to),
+      compiler.encode_uchar4(type, convert_from, convert_to),
       compiler.encode_uchar4(compiler.stack_assign(vector_in), compiler.stack_assign(vector_out)));
 }