User:KevinDietrich/CyclesNodes

Cycles Nodes
This page references the various nodes which can be used in Cycles. There are two categories of Nodes, the "top level" ones, which define the content of the Scene, and the "shader graph" ones, which describe a Shader network.

Top Level Nodes
Those are the nodes that make up a Cycles Scene.

Alembic

 * Sockets
 * Filename
 * filepath string
 * Frame
 * frame float
 * Start Frame
 * start_frame float
 * End Frame
 * end_frame float
 * Frame Rate
 * frame_rate float
 * Frame Offset
 * frame_offset float
 * Default Radius
 * default_radius float
 * Scale
 * scale float
 * Objects
 * objects array_node

Alembic Object

 * Sockets
 * Alembic Path
 * path string
 * Used Shaders
 * used_shaders array_node
 * Max Subdivision Level
 * subd_max_level int
 * Subdivision Dicing Rate
 * subd_dicing_rate float
 * Radius Scale
 * radius_scale float

Background

 * Sockets
 * AO Factor
 * ao_factor float
 * AO Distance
 * ao_distance float
 * Use Shader
 * use_shader boolean
 * Use AO
 * use_ao boolean
 * Visibility
 * visibility uint
 * Transparent
 * transparent boolean
 * Transparent Glass
 * transparent_glass boolean
 * Transparent Roughness Threshold
 * transparent_roughness_threshold float
 * Volume Step Size
 * volume_step_size float
 * Shader
 * shader node

Camera

 * Sockets
 * Shutter Time
 * shuttertime float
 * Motion Position
 * motion_position enum
 * Rolling Shutter Type
 * rolling_shutter_type enum
 * Rolling Shutter Duration
 * rolling_shutter_duration float
 * Shutter Curve
 * shutter_curve array_float
 * Aperture Size
 * aperturesize float
 * Focal Distance
 * focaldistance float
 * Blades
 * blades uint
 * Blades Rotation
 * bladesrotation float
 * Matrix
 * matrix transform
 * Motion
 * motion array_transform
 * Aperture Ratio
 * aperture_ratio float
 * Type
 * camera_type enum
 * Panorama Type
 * panorama_type enum
 * Fisheye FOV
 * fisheye_fov float
 * Fisheye Lens
 * fisheye_lens float
 * Latitude Min
 * latitude_min float
 * Latitude Max
 * latitude_max float
 * Longitude Min
 * longitude_min float
 * Longitude Max
 * longitude_max float
 * FOV
 * fov float
 * FOV Pre
 * fov_pre float
 * FOV Post
 * fov_post float
 * Stereo Eye
 * stereo_eye enum
 * Use Spherical Stereo
 * use_spherical_stereo boolean
 * Interocular Distance
 * interocular_distance float
 * Convergence Distance
 * convergence_distance float
 * Use Pole Merge
 * use_pole_merge boolean
 * Pole Merge Angle From
 * pole_merge_angle_from float
 * Pole Merge Angle To
 * pole_merge_angle_to float
 * Sensor Width
 * sensorwidth float
 * Sensor Height
 * sensorheight float
 * Near Clip
 * nearclip float
 * Far Clip
 * farclip float
 * Viewplane Left
 * viewplane.left float
 * Viewplane Right
 * viewplane.right float
 * Viewplane Bottom
 * viewplane.bottom float
 * Viewplane Top
 * viewplane.top float
 * Border Left
 * border.left float
 * Border Right
 * border.right float
 * Border Bottom
 * border.bottom float
 * Border Top
 * border.top float
 * Viewport Border Left
 * viewport_camera_border.left float
 * Viewport Border Right
 * viewport_camera_border.right float
 * Viewport Border Bottom
 * viewport_camera_border.bottom float
 * Viewport Border Top
 * viewport_camera_border.top float
 * Offscreen Dicing Scale
 * offscreen_dicing_scale float
 * Full Width
 * full_width int
 * Full Height
 * full_height int
 * Use Perspective Motion
 * use_perspective_motion boolean

Film

 * Sockets
 * Exposure
 * exposure float
 * Pass Alpha Threshold
 * pass_alpha_threshold float
 * Filter Type
 * filter_type enum
 * Filter Width
 * filter_width float
 * Mist Start
 * mist_start float
 * Mist Depth
 * mist_depth float
 * Mist Falloff
 * mist_falloff float
 * Generate Denoising Data Pass
 * denoising_data_pass boolean
 * Generate Denoising Clean Pass
 * denoising_clean_pass boolean
 * Generate Denoising Prefiltered Pass
 * denoising_prefiltered_pass boolean
 * Denoising Flags
 * denoising_flags int
 * Use Adaptive Sampling
 * use_adaptive_sampling boolean
 * Use Light Visibility
 * use_light_visibility boolean
 * Display Pass
 * display_pass enum
 * Cryptomatte Passes
 * cryptomatte_passes enum
 * Cryptomatte Depth
 * cryptomatte_depth int

Geometry Base

 * Sockets
 * Motion Steps
 * motion_steps uint
 * Use Motion Blur
 * use_motion_blur boolean
 * Shaders
 * used_shaders array_node

Hair

 * Base : geometry_base
 * Sockets
 * Motion Steps
 * motion_steps uint
 * Use Motion Blur
 * use_motion_blur boolean
 * Shaders
 * used_shaders array_node
 * Curve Keys
 * curve_keys array_point
 * Curve Radius
 * curve_radius array_float
 * Curve First Key
 * curve_first_key array_int
 * Curve Shader
 * curve_shader array_int

Integrator

 * Sockets
 * Min Bounce
 * min_bounce int
 * Max Bounce
 * max_bounce int
 * Max Diffuse Bounce
 * max_diffuse_bounce int
 * Max Glossy Bounce
 * max_glossy_bounce int
 * Max Transmission Bounce
 * max_transmission_bounce int
 * Max Volume Bounce
 * max_volume_bounce int
 * Transparent Min Bounce
 * transparent_min_bounce int
 * Transparent Max Bounce
 * transparent_max_bounce int
 * AO Bounces
 * ao_bounces int
 * Volume Max Steps
 * volume_max_steps int
 * Volume Step Rate
 * volume_step_rate float
 * Reflective Caustics
 * caustics_reflective boolean
 * Refractive Caustics
 * caustics_refractive boolean
 * Filter Glossy
 * filter_glossy float
 * Seed
 * seed int
 * Sample Clamp Direct
 * sample_clamp_direct float
 * Sample Clamp Indirect
 * sample_clamp_indirect float
 * Motion Blur
 * motion_blur boolean
 * AA Samples
 * aa_samples int
 * Diffuse Samples
 * diffuse_samples int
 * Glossy Samples
 * glossy_samples int
 * Transmission Samples
 * transmission_samples int
 * AO Samples
 * ao_samples int
 * Mesh Light Samples
 * mesh_light_samples int
 * Subsurface Samples
 * subsurface_samples int
 * Volume Samples
 * volume_samples int
 * Start Sample
 * start_sample int
 * Adaptive Threshold
 * adaptive_threshold float
 * Adaptive Min Samples
 * adaptive_min_samples int
 * Sample All Lights Direct
 * sample_all_lights_direct boolean
 * Sample All Lights Indirect
 * sample_all_lights_indirect boolean
 * Light Sampling Threshold
 * light_sampling_threshold float
 * Method
 * method enum
 * Sampling Pattern
 * sampling_pattern enum

Light

 * Sockets
 * Type
 * light_type enum
 * Strength
 * strength color
 * Co
 * co point
 * Dir
 * dir vector
 * Size
 * size float
 * Angle
 * angle float
 * Axis U
 * axisu vector
 * Size U
 * sizeu float
 * Axis V
 * axisv vector
 * Size V
 * sizev float
 * Round
 * round boolean
 * Spread
 * spread float
 * Map Resolution
 * map_resolution int
 * Spot Angle
 * spot_angle float
 * Spot Smooth
 * spot_smooth float
 * Transform
 * tfm transform
 * Cast Shadow
 * cast_shadow boolean
 * Use Mis
 * use_mis boolean
 * Use Diffuse
 * use_diffuse boolean
 * Use Glossy
 * use_glossy boolean
 * Use Transmission
 * use_transmission boolean
 * Use Scatter
 * use_scatter boolean
 * Samples
 * samples int
 * Max Bounces
 * max_bounces int
 * Random ID
 * random_id uint
 * Is Portal
 * is_portal boolean
 * Is Enabled
 * is_enabled boolean
 * Shader
 * shader node

Mesh

 * Base : geometry_base
 * Sockets
 * Motion Steps
 * motion_steps uint
 * Use Motion Blur
 * use_motion_blur boolean
 * Shaders
 * used_shaders array_node
 * Triangles
 * triangles array_int
 * Vertices
 * verts array_point
 * Shader
 * shader array_int
 * Smooth
 * smooth array_boolean
 * Triangle Patch
 * triangle_patch array_int
 * Patch UVs
 * vert_patch_uv array_point2
 * Subdivision Type
 * subdivision_type enum
 * Subdivision Crease Edges
 * subd_creases_edge array_int
 * Subdivision Crease Weights
 * subd_creases_weight array_float
 * Subdivision Face Corners
 * subd_face_corners array_int
 * Subdivision Face Start Corner
 * subd_start_corner array_int
 * Subdivision Face Corner Count
 * subd_num_corners array_int
 * Subdivision Face Shader
 * subd_shader array_int
 * Subdivision Face Smooth
 * subd_smooth array_boolean
 * Subdivision Face PTex Offset
 * subd_ptex_offset array_int
 * NGons Number
 * num_ngons int
 * Subdivision Dicing Rate
 * subd_dicing_rate float
 * Subdivision Dicing Rate
 * subd_max_level int
 * Subdivision Object Transform
 * subd_objecttoworld transform

Object

 * Sockets
 * Geometry
 * geometry node
 * Transform
 * tfm transform
 * Visibility
 * visibility uint
 * Color
 * color color
 * Random ID
 * random_id uint
 * Pass ID
 * pass_id int
 * Use Holdout
 * use_holdout boolean
 * Hide on Missing Motion
 * hide_on_missing_motion boolean
 * Dupli Generated
 * dupli_generated point
 * Dupli UV
 * dupli_uv point2
 * Motion
 * motion array_transform
 * Terminator Offset
 * shadow_terminator_offset float
 * Asset Name
 * asset_name string
 * Shadow Catcher
 * is_shadow_catcher boolean
 * Particle System
 * particle_system node
 * Particle Index
 * particle_index int

Particle System

 * Sockets

Pass

 * Sockets
 * Type
 * type enum
 * Name
 * name string

Shader

 * Sockets
 * Use MIS
 * use_mis boolean
 * Use Transparent Shadow
 * use_transparent_shadow boolean
 * Heterogeneous Volume
 * heterogeneous_volume boolean
 * Volume Sampling Method
 * volume_sampling_method enum
 * Volume Interpolation Method
 * volume_interpolation_method enum
 * Volume Step Rate
 * volume_step_rate float
 * Displacement Method
 * displacement_method enum
 * Pass ID
 * pass_id int

Volume

 * Base : mesh
 * Sockets
 * Motion Steps
 * motion_steps uint
 * Use Motion Blur
 * use_motion_blur boolean
 * Shaders
 * used_shaders array_node
 * Triangles
 * triangles array_int
 * Vertices
 * verts array_point
 * Shader
 * shader array_int
 * Smooth
 * smooth array_boolean
 * Triangle Patch
 * triangle_patch array_int
 * Patch UVs
 * vert_patch_uv array_point2
 * Subdivision Type
 * subdivision_type enum
 * Subdivision Crease Edges
 * subd_creases_edge array_int
 * Subdivision Crease Weights
 * subd_creases_weight array_float
 * Subdivision Face Corners
 * subd_face_corners array_int
 * Subdivision Face Start Corner
 * subd_start_corner array_int
 * Subdivision Face Corner Count
 * subd_num_corners array_int
 * Subdivision Face Shader
 * subd_shader array_int
 * Subdivision Face Smooth
 * subd_smooth array_boolean
 * Subdivision Face PTex Offset
 * subd_ptex_offset array_int
 * NGons Number
 * num_ngons int
 * Subdivision Dicing Rate
 * subd_dicing_rate float
 * Subdivision Dicing Rate
 * subd_max_level int
 * Subdivision Object Transform
 * subd_objecttoworld transform
 * Clipping
 * clipping float
 * Step Size
 * step_size float
 * Object Space
 * object_space boolean

Shader Graph Nodes
Those are the nodes that make up a Cycles Shader graph.

Absorption Volume

 * Input Sockets
 * Color
 * color color
 * Density
 * density float
 * VolumeMixWeight
 * volume_mix_weight float
 * Output Sockets
 * Volume
 * volume closure

Add Closure

 * Input Sockets
 * Closure1
 * closure1 closure
 * Closure2
 * closure2 closure
 * Output Sockets
 * Closure
 * closure closure

Ambient Occlusion

 * Input Sockets
 * Samples
 * samples int
 * Color
 * color color
 * Distance
 * distance float
 * Normal
 * normal normal
 * Inside
 * inside boolean
 * Only Local
 * only_local boolean
 * Output Sockets
 * Color
 * color color
 * AO
 * ao float

Anisotropic Bsdf

 * Input Sockets
 * Color
 * color color
 * Normal
 * normal normal
 * SurfaceMixWeight
 * surface_mix_weight float
 * Distribution
 * distribution enum
 * Tangent
 * tangent vector
 * Roughness
 * roughness float
 * Anisotropy
 * anisotropy float
 * Rotation
 * rotation float
 * Output Sockets
 * BSDF
 * BSDF closure

Aov Output

 * Input Sockets
 * Color
 * color color
 * Value
 * value float
 * AOV Name
 * name string

Attribute

 * Input Sockets
 * Attribute
 * attribute string
 * Output Sockets
 * Color
 * color color
 * Vector
 * vector vector
 * Fac
 * fac float
 * Alpha
 * alpha float

Background Shader

 * Input Sockets
 * Color
 * color color
 * Strength
 * strength float
 * SurfaceMixWeight
 * surface_mix_weight float
 * Output Sockets
 * Background
 * background closure

Bevel

 * Input Sockets
 * Samples
 * samples int
 * Radius
 * radius float
 * Normal
 * normal normal
 * Output Sockets
 * Normal
 * bevel normal

Blackbody

 * Input Sockets
 * Temperature
 * temperature float
 * Output Sockets
 * Color
 * color color

Brick Texture

 * Input Sockets
 * Translation
 * tex_mapping.translation point
 * Rotation
 * tex_mapping.rotation vector
 * Scale
 * tex_mapping.scale vector
 * Min
 * tex_mapping.min vector
 * Max
 * tex_mapping.max vector
 * Use Min Max
 * tex_mapping.use_minmax boolean
 * x_mapping
 * tex_mapping.x_mapping enum
 * y_mapping
 * tex_mapping.y_mapping enum
 * z_mapping
 * tex_mapping.z_mapping enum
 * Type
 * tex_mapping.type enum
 * Projection
 * tex_mapping.projection enum
 * Offset
 * offset float
 * Offset Frequency
 * offset_frequency int
 * Squash
 * squash float
 * Squash Frequency
 * squash_frequency int
 * Vector
 * vector point
 * Color1
 * color1 color
 * Color2
 * color2 color
 * Mortar
 * mortar color
 * Scale
 * scale float
 * Mortar Size
 * mortar_size float
 * Mortar Smooth
 * mortar_smooth float
 * Bias
 * bias float
 * Brick Width
 * brick_width float
 * Row Height
 * row_height float
 * Output Sockets
 * Color
 * color color
 * Fac
 * fac float

Brightness Contrast

 * Input Sockets
 * Color
 * color color
 * Bright
 * bright float
 * Contrast
 * contrast float
 * Output Sockets
 * Color
 * color color

Bump

 * Input Sockets
 * Invert
 * invert boolean
 * UseObjectSpace
 * use_object_space boolean
 * Height
 * height float
 * SampleCenter
 * sample_center float
 * SampleX
 * sample_x float
 * SampleY
 * sample_y float
 * Normal
 * normal normal
 * Strength
 * strength float
 * Distance
 * distance float
 * Output Sockets
 * Normal
 * normal normal

Camera Info

 * Output Sockets
 * View Vector
 * view_vector vector
 * View Z Depth
 * view_z_depth float
 * View Distance
 * view_distance float

Checker Texture

 * Input Sockets
 * Translation
 * tex_mapping.translation point
 * Rotation
 * tex_mapping.rotation vector
 * Scale
 * tex_mapping.scale vector
 * Min
 * tex_mapping.min vector
 * Max
 * tex_mapping.max vector
 * Use Min Max
 * tex_mapping.use_minmax boolean
 * x_mapping
 * tex_mapping.x_mapping enum
 * y_mapping
 * tex_mapping.y_mapping enum
 * z_mapping
 * tex_mapping.z_mapping enum
 * Type
 * tex_mapping.type enum
 * Projection
 * tex_mapping.projection enum
 * Vector
 * vector point
 * Color1
 * color1 color
 * Color2
 * color2 color
 * Scale
 * scale float
 * Output Sockets
 * Color
 * color color
 * Fac
 * fac float

Clamp

 * Input Sockets
 * Type
 * clamp_type enum
 * Value
 * value float
 * Min
 * min float
 * Max
 * max float
 * Output Sockets
 * Result
 * result float

Color

 * Input Sockets
 * Value
 * value color
 * Output Sockets
 * Color
 * color color

Combine Hsv

 * Input Sockets
 * H
 * h float
 * S
 * s float
 * V
 * v float
 * Output Sockets
 * Color
 * color color

Combine Rgb

 * Input Sockets
 * R
 * r float
 * G
 * g float
 * B
 * b float
 * Output Sockets
 * Image
 * image color

Combine Xyz

 * Input Sockets
 * X
 * x float
 * Y
 * y float
 * Z
 * z float
 * Output Sockets
 * Vector
 * vector vector

Convert Closure To Closure

 * Input Sockets
 * value_closure
 * value_closure closure
 * Output Sockets
 * value_closure
 * value_closure closure

Convert Closure To Color

 * Input Sockets
 * value_closure
 * value_closure closure
 * Output Sockets
 * value_color
 * value_color color

Convert Closure To Float

 * Input Sockets
 * value_closure
 * value_closure closure
 * Output Sockets
 * value_float
 * value_float float

Convert Closure To Int

 * Input Sockets
 * value_closure
 * value_closure closure
 * Output Sockets
 * value_int
 * value_int int

Convert Closure To Normal

 * Input Sockets
 * value_closure
 * value_closure closure
 * Output Sockets
 * value_normal
 * value_normal normal

Convert Closure To Point

 * Input Sockets
 * value_closure
 * value_closure closure
 * Output Sockets
 * value_point
 * value_point point

Convert Closure To String

 * Input Sockets
 * value_closure
 * value_closure closure
 * Output Sockets
 * value_string
 * value_string string

Convert Closure To Vector

 * Input Sockets
 * value_closure
 * value_closure closure
 * Output Sockets
 * value_vector
 * value_vector vector

Convert Color To Closure

 * Input Sockets
 * value_color
 * value_color color
 * Output Sockets
 * value_closure
 * value_closure closure

Convert Color To Color

 * Input Sockets
 * value_color
 * value_color color
 * Output Sockets
 * value_color
 * value_color color

Convert Color To Float

 * Input Sockets
 * value_color
 * value_color color
 * Output Sockets
 * value_float
 * value_float float

Convert Color To Int

 * Input Sockets
 * value_color
 * value_color color
 * Output Sockets
 * value_int
 * value_int int

Convert Color To Normal

 * Input Sockets
 * value_color
 * value_color color
 * Output Sockets
 * value_normal
 * value_normal normal

Convert Color To Point

 * Input Sockets
 * value_color
 * value_color color
 * Output Sockets
 * value_point
 * value_point point

Convert Color To String

 * Input Sockets
 * value_color
 * value_color color
 * Output Sockets
 * value_string
 * value_string string

Convert Color To Vector

 * Input Sockets
 * value_color
 * value_color color
 * Output Sockets
 * value_vector
 * value_vector vector

Convert Float To Closure

 * Input Sockets
 * value_float
 * value_float float
 * Output Sockets
 * value_closure
 * value_closure closure

Convert Float To Color

 * Input Sockets
 * value_float
 * value_float float
 * Output Sockets
 * value_color
 * value_color color

Convert Float To Float

 * Input Sockets
 * value_float
 * value_float float
 * Output Sockets
 * value_float
 * value_float float

Convert Float To Int

 * Input Sockets
 * value_float
 * value_float float
 * Output Sockets
 * value_int
 * value_int int

Convert Float To Normal

 * Input Sockets
 * value_float
 * value_float float
 * Output Sockets
 * value_normal
 * value_normal normal

Convert Float To Point

 * Input Sockets
 * value_float
 * value_float float
 * Output Sockets
 * value_point
 * value_point point

Convert Float To String

 * Input Sockets
 * value_float
 * value_float float
 * Output Sockets
 * value_string
 * value_string string

Convert Float To Vector

 * Input Sockets
 * value_float
 * value_float float
 * Output Sockets
 * value_vector
 * value_vector vector

Convert Int To Closure

 * Input Sockets
 * value_int
 * value_int int
 * Output Sockets
 * value_closure
 * value_closure closure

Convert Int To Color

 * Input Sockets
 * value_int
 * value_int int
 * Output Sockets
 * value_color
 * value_color color

Convert Int To Float

 * Input Sockets
 * value_int
 * value_int int
 * Output Sockets
 * value_float
 * value_float float

Convert Int To Int

 * Input Sockets
 * value_int
 * value_int int
 * Output Sockets
 * value_int
 * value_int int

Convert Int To Normal

 * Input Sockets
 * value_int
 * value_int int
 * Output Sockets
 * value_normal
 * value_normal normal

Convert Int To Point

 * Input Sockets
 * value_int
 * value_int int
 * Output Sockets
 * value_point
 * value_point point

Convert Int To String

 * Input Sockets
 * value_int
 * value_int int
 * Output Sockets
 * value_string
 * value_string string

Convert Int To Vector

 * Input Sockets
 * value_int
 * value_int int
 * Output Sockets
 * value_vector
 * value_vector vector

Convert Normal To Closure

 * Input Sockets
 * value_normal
 * value_normal normal
 * Output Sockets
 * value_closure
 * value_closure closure

Convert Normal To Color

 * Input Sockets
 * value_normal
 * value_normal normal
 * Output Sockets
 * value_color
 * value_color color

Convert Normal To Float

 * Input Sockets
 * value_normal
 * value_normal normal
 * Output Sockets
 * value_float
 * value_float float

Convert Normal To Int

 * Input Sockets
 * value_normal
 * value_normal normal
 * Output Sockets
 * value_int
 * value_int int

Convert Normal To Normal

 * Input Sockets
 * value_normal
 * value_normal normal
 * Output Sockets
 * value_normal
 * value_normal normal

Convert Normal To Point

 * Input Sockets
 * value_normal
 * value_normal normal
 * Output Sockets
 * value_point
 * value_point point

Convert Normal To String

 * Input Sockets
 * value_normal
 * value_normal normal
 * Output Sockets
 * value_string
 * value_string string

Convert Normal To Vector

 * Input Sockets
 * value_normal
 * value_normal normal
 * Output Sockets
 * value_vector
 * value_vector vector

Convert Point To Closure

 * Input Sockets
 * value_point
 * value_point point
 * Output Sockets
 * value_closure
 * value_closure closure

Convert Point To Color

 * Input Sockets
 * value_point
 * value_point point
 * Output Sockets
 * value_color
 * value_color color

Convert Point To Float

 * Input Sockets
 * value_point
 * value_point point
 * Output Sockets
 * value_float
 * value_float float

Convert Point To Int

 * Input Sockets
 * value_point
 * value_point point
 * Output Sockets
 * value_int
 * value_int int

Convert Point To Normal

 * Input Sockets
 * value_point
 * value_point point
 * Output Sockets
 * value_normal
 * value_normal normal

Convert Point To Point

 * Input Sockets
 * value_point
 * value_point point
 * Output Sockets
 * value_point
 * value_point point

Convert Point To String

 * Input Sockets
 * value_point
 * value_point point
 * Output Sockets
 * value_string
 * value_string string

Convert Point To Vector

 * Input Sockets
 * value_point
 * value_point point
 * Output Sockets
 * value_vector
 * value_vector vector

Convert String To Closure

 * Input Sockets
 * value_string
 * value_string string
 * Output Sockets
 * value_closure
 * value_closure closure

Convert String To Color

 * Input Sockets
 * value_string
 * value_string string
 * Output Sockets
 * value_color
 * value_color color

Convert String To Float

 * Input Sockets
 * value_string
 * value_string string
 * Output Sockets
 * value_float
 * value_float float

Convert String To Int

 * Input Sockets
 * value_string
 * value_string string
 * Output Sockets
 * value_int
 * value_int int

Convert String To Normal

 * Input Sockets
 * value_string
 * value_string string
 * Output Sockets
 * value_normal
 * value_normal normal

Convert String To Point

 * Input Sockets
 * value_string
 * value_string string
 * Output Sockets
 * value_point
 * value_point point

Convert String To String

 * Input Sockets
 * value_string
 * value_string string
 * Output Sockets
 * value_string
 * value_string string

Convert String To Vector

 * Input Sockets
 * value_string
 * value_string string
 * Output Sockets
 * value_vector
 * value_vector vector

Convert Vector To Closure

 * Input Sockets
 * value_vector
 * value_vector vector
 * Output Sockets
 * value_closure
 * value_closure closure

Convert Vector To Color

 * Input Sockets
 * value_vector
 * value_vector vector
 * Output Sockets
 * value_color
 * value_color color

Convert Vector To Float

 * Input Sockets
 * value_vector
 * value_vector vector
 * Output Sockets
 * value_float
 * value_float float

Convert Vector To Int

 * Input Sockets
 * value_vector
 * value_vector vector
 * Output Sockets
 * value_int
 * value_int int

Convert Vector To Normal

 * Input Sockets
 * value_vector
 * value_vector vector
 * Output Sockets
 * value_normal
 * value_normal normal

Convert Vector To Point

 * Input Sockets
 * value_vector
 * value_vector vector
 * Output Sockets
 * value_point
 * value_point point

Convert Vector To String

 * Input Sockets
 * value_vector
 * value_vector vector
 * Output Sockets
 * value_string
 * value_string string

Convert Vector To Vector

 * Input Sockets
 * value_vector
 * value_vector vector
 * Output Sockets
 * value_vector
 * value_vector vector

Diffuse Bsdf

 * Input Sockets
 * Color
 * color color
 * Normal
 * normal normal
 * SurfaceMixWeight
 * surface_mix_weight float
 * Roughness
 * roughness float
 * Output Sockets
 * BSDF
 * BSDF closure

Displacement

 * Input Sockets
 * Space
 * space enum
 * Height
 * height float
 * Midlevel
 * midlevel float
 * Scale
 * scale float
 * Normal
 * normal normal
 * Output Sockets
 * Displacement
 * displacement vector

Emission

 * Input Sockets
 * Color
 * color color
 * Strength
 * strength float
 * SurfaceMixWeight
 * surface_mix_weight float
 * Output Sockets
 * Emission
 * emission closure

Environment Texture

 * Input Sockets
 * Translation
 * tex_mapping.translation point
 * Rotation
 * tex_mapping.rotation vector
 * Scale
 * tex_mapping.scale vector
 * Min
 * tex_mapping.min vector
 * Max
 * tex_mapping.max vector
 * Use Min Max
 * tex_mapping.use_minmax boolean
 * x_mapping
 * tex_mapping.x_mapping enum
 * y_mapping
 * tex_mapping.y_mapping enum
 * z_mapping
 * tex_mapping.z_mapping enum
 * Type
 * tex_mapping.type enum
 * Projection
 * tex_mapping.projection enum
 * Filename
 * filename string
 * Colorspace
 * colorspace string
 * Alpha Type
 * alpha_type enum
 * Interpolation
 * interpolation enum
 * Projection
 * projection enum
 * Animated
 * animated boolean
 * Vector
 * vector point
 * Output Sockets
 * Color
 * color color
 * Alpha
 * alpha float

Fresnel

 * Input Sockets
 * Normal
 * normal normal
 * IOR
 * IOR float
 * Output Sockets
 * Fac
 * fac float

Gamma

 * Input Sockets
 * Color
 * color color
 * Gamma
 * gamma float
 * Output Sockets
 * Color
 * color color

Geometry

 * Input Sockets
 * NormalIn
 * normal_osl normal
 * Output Sockets
 * Position
 * position point
 * Normal
 * normal normal
 * Tangent
 * tangent normal
 * True Normal
 * true_normal normal
 * Incoming
 * incoming vector
 * Parametric
 * parametric point
 * Backfacing
 * backfacing float
 * Pointiness
 * pointiness float
 * Random Per Island
 * random_per_island float

Glass Bsdf

 * Input Sockets
 * Color
 * color color
 * Normal
 * normal normal
 * SurfaceMixWeight
 * surface_mix_weight float
 * Distribution
 * distribution enum
 * Roughness
 * roughness float
 * IOR
 * IOR float
 * Output Sockets
 * BSDF
 * BSDF closure

Glossy Bsdf

 * Input Sockets
 * Color
 * color color
 * Normal
 * normal normal
 * SurfaceMixWeight
 * surface_mix_weight float
 * Distribution
 * distribution enum
 * Roughness
 * roughness float
 * Output Sockets
 * BSDF
 * BSDF closure

Gradient Texture

 * Input Sockets
 * Translation
 * tex_mapping.translation point
 * Rotation
 * tex_mapping.rotation vector
 * Scale
 * tex_mapping.scale vector
 * Min
 * tex_mapping.min vector
 * Max
 * tex_mapping.max vector
 * Use Min Max
 * tex_mapping.use_minmax boolean
 * x_mapping
 * tex_mapping.x_mapping enum
 * y_mapping
 * tex_mapping.y_mapping enum
 * z_mapping
 * tex_mapping.z_mapping enum
 * Type
 * tex_mapping.type enum
 * Projection
 * tex_mapping.projection enum
 * Type
 * gradient_type enum
 * Vector
 * vector point
 * Output Sockets
 * Color
 * color color
 * Fac
 * fac float

Hair Bsdf

 * Input Sockets
 * Color
 * color color
 * Normal
 * normal normal
 * SurfaceMixWeight
 * surface_mix_weight float
 * Component
 * component enum
 * Offset
 * offset float
 * RoughnessU
 * roughness_u float
 * RoughnessV
 * roughness_v float
 * Tangent
 * tangent vector
 * Output Sockets
 * BSDF
 * BSDF closure

Hair Info

 * Output Sockets
 * Is Strand
 * is_strand float
 * Intercept
 * intercept float
 * Thickness
 * thickness float
 * Tangent Normal
 * tangent_normal normal
 * Random
 * index float

Holdout

 * Input Sockets
 * SurfaceMixWeight
 * surface_mix_weight float
 * VolumeMixWeight
 * volume_mix_weight float
 * Output Sockets
 * Holdout
 * holdout closure

Hsv

 * Input Sockets
 * Hue
 * hue float
 * Saturation
 * saturation float
 * Value
 * value float
 * Fac
 * fac float
 * Color
 * color color
 * Output Sockets
 * Color
 * color color

Ies Light

 * Input Sockets
 * Translation
 * tex_mapping.translation point
 * Rotation
 * tex_mapping.rotation vector
 * Scale
 * tex_mapping.scale vector
 * Min
 * tex_mapping.min vector
 * Max
 * tex_mapping.max vector
 * Use Min Max
 * tex_mapping.use_minmax boolean
 * x_mapping
 * tex_mapping.x_mapping enum
 * y_mapping
 * tex_mapping.y_mapping enum
 * z_mapping
 * tex_mapping.z_mapping enum
 * Type
 * tex_mapping.type enum
 * Projection
 * tex_mapping.projection enum
 * IES
 * ies string
 * File Name
 * filename string
 * Strength
 * strength float
 * Vector
 * vector point
 * Output Sockets
 * Fac
 * fac float

Image Texture

 * Input Sockets
 * Translation
 * tex_mapping.translation point
 * Rotation
 * tex_mapping.rotation vector
 * Scale
 * tex_mapping.scale vector
 * Min
 * tex_mapping.min vector
 * Max
 * tex_mapping.max vector
 * Use Min Max
 * tex_mapping.use_minmax boolean
 * x_mapping
 * tex_mapping.x_mapping enum
 * y_mapping
 * tex_mapping.y_mapping enum
 * z_mapping
 * tex_mapping.z_mapping enum
 * Type
 * tex_mapping.type enum
 * Projection
 * tex_mapping.projection enum
 * Filename
 * filename string
 * Colorspace
 * colorspace string
 * Alpha Type
 * alpha_type enum
 * Interpolation
 * interpolation enum
 * Extension
 * extension enum
 * Projection
 * projection enum
 * Projection Blend
 * projection_blend float
 * Tiles
 * tiles array_int
 * Animated
 * animated boolean
 * Vector
 * vector point
 * Output Sockets
 * Color
 * color color
 * Alpha
 * alpha float

Invert

 * Input Sockets
 * Fac
 * fac float
 * Color
 * color color
 * Output Sockets
 * Color
 * color color

Layer Weight

 * Input Sockets
 * Normal
 * normal normal
 * Blend
 * blend float
 * Output Sockets
 * Fresnel
 * fresnel float
 * Facing
 * facing float

Light Falloff

 * Input Sockets
 * Strength
 * strength float
 * Smooth
 * smooth float
 * Output Sockets
 * Quadratic
 * quadratic float
 * Linear
 * linear float
 * Constant
 * constant float

Light Path

 * Output Sockets
 * Is Camera Ray
 * is_camera_ray float
 * Is Shadow Ray
 * is_shadow_ray float
 * Is Diffuse Ray
 * is_diffuse_ray float
 * Is Glossy Ray
 * is_glossy_ray float
 * Is Singular Ray
 * is_singular_ray float
 * Is Reflection Ray
 * is_reflection_ray float
 * Is Transmission Ray
 * is_transmission_ray float
 * Is Volume Scatter Ray
 * is_volume_scatter_ray float
 * Ray Length
 * ray_length float
 * Ray Depth
 * ray_depth float
 * Diffuse Depth
 * diffuse_depth float
 * Glossy Depth
 * glossy_depth float
 * Transparent Depth
 * transparent_depth float
 * Transmission Depth
 * transmission_depth float

Magic Texture

 * Input Sockets
 * Translation
 * tex_mapping.translation point
 * Rotation
 * tex_mapping.rotation vector
 * Scale
 * tex_mapping.scale vector
 * Min
 * tex_mapping.min vector
 * Max
 * tex_mapping.max vector
 * Use Min Max
 * tex_mapping.use_minmax boolean
 * x_mapping
 * tex_mapping.x_mapping enum
 * y_mapping
 * tex_mapping.y_mapping enum
 * z_mapping
 * tex_mapping.z_mapping enum
 * Type
 * tex_mapping.type enum
 * Projection
 * tex_mapping.projection enum
 * Depth
 * depth int
 * Vector
 * vector point
 * Scale
 * scale float
 * Distortion
 * distortion float
 * Output Sockets
 * Color
 * color color
 * Fac
 * fac float

Map Range

 * Input Sockets
 * Type
 * range_type enum
 * Value
 * value float
 * From Min
 * from_min float
 * From Max
 * from_max float
 * To Min
 * to_min float
 * To Max
 * to_max float
 * Steps
 * steps float
 * Clamp
 * clamp boolean
 * Output Sockets
 * Result
 * result float

Mapping

 * Input Sockets
 * Type
 * mapping_type enum
 * Vector
 * vector point
 * Location
 * location point
 * Rotation
 * rotation point
 * Scale
 * scale point
 * Output Sockets
 * Vector
 * vector point

Math

 * Input Sockets
 * Type
 * math_type enum
 * Use Clamp
 * use_clamp boolean
 * Value1
 * value1 float
 * Value2
 * value2 float
 * Value3
 * value3 float
 * Output Sockets
 * Value
 * value float

Mix

 * Input Sockets
 * Type
 * mix_type enum
 * Use Clamp
 * use_clamp boolean
 * Fac
 * fac float
 * Color1
 * color1 color
 * Color2
 * color2 color
 * Output Sockets
 * Color
 * color color

Mix Closure

 * Input Sockets
 * Fac
 * fac float
 * Closure1
 * closure1 closure
 * Closure2
 * closure2 closure
 * Output Sockets
 * Closure
 * closure closure

Mix Closure Weight

 * Input Sockets
 * Weight
 * weight float
 * Fac
 * fac float
 * Output Sockets
 * Weight1
 * weight1 float
 * Weight2
 * weight2 float

Musgrave Texture

 * Input Sockets
 * Translation
 * tex_mapping.translation point
 * Rotation
 * tex_mapping.rotation vector
 * Scale
 * tex_mapping.scale vector
 * Min
 * tex_mapping.min vector
 * Max
 * tex_mapping.max vector
 * Use Min Max
 * tex_mapping.use_minmax boolean
 * x_mapping
 * tex_mapping.x_mapping enum
 * y_mapping
 * tex_mapping.y_mapping enum
 * z_mapping
 * tex_mapping.z_mapping enum
 * Type
 * tex_mapping.type enum
 * Projection
 * tex_mapping.projection enum
 * Dimensions
 * dimensions enum
 * Type
 * musgrave_type enum
 * Vector
 * vector point
 * W
 * w float
 * Scale
 * scale float
 * Detail
 * detail float
 * Dimension
 * dimension float
 * Lacunarity
 * lacunarity float
 * Offset
 * offset float
 * Gain
 * gain float
 * Output Sockets
 * Fac
 * fac float

Noise Texture

 * Input Sockets
 * Translation
 * tex_mapping.translation point
 * Rotation
 * tex_mapping.rotation vector
 * Scale
 * tex_mapping.scale vector
 * Min
 * tex_mapping.min vector
 * Max
 * tex_mapping.max vector
 * Use Min Max
 * tex_mapping.use_minmax boolean
 * x_mapping
 * tex_mapping.x_mapping enum
 * y_mapping
 * tex_mapping.y_mapping enum
 * z_mapping
 * tex_mapping.z_mapping enum
 * Type
 * tex_mapping.type enum
 * Projection
 * tex_mapping.projection enum
 * Dimensions
 * dimensions enum
 * Vector
 * vector point
 * W
 * w float
 * Scale
 * scale float
 * Detail
 * detail float
 * Roughness
 * roughness float
 * Distortion
 * distortion float
 * Output Sockets
 * Fac
 * fac float
 * Color
 * color color

Normal

 * Input Sockets
 * direction
 * direction vector
 * Normal
 * normal normal
 * Output Sockets
 * Normal
 * normal normal
 * Dot
 * dot float

Normal Map

 * Input Sockets
 * Space
 * space enum
 * Attribute
 * attribute string
 * NormalIn
 * normal_osl normal
 * Strength
 * strength float
 * Color
 * color color
 * Output Sockets
 * Normal
 * normal normal

Object Info

 * Output Sockets
 * Location
 * location vector
 * Color
 * color color
 * Object Index
 * object_index float
 * Material Index
 * material_index float
 * Random
 * random float

Output

 * Input Sockets
 * Surface
 * surface closure
 * Volume
 * volume closure
 * Displacement
 * displacement vector
 * Normal
 * normal normal

Particle Info

 * Output Sockets
 * Index
 * index float
 * Random
 * random float
 * Age
 * age float
 * Lifetime
 * lifetime float
 * Location
 * location point
 * Size
 * size float
 * Velocity
 * velocity vector
 * Angular Velocity
 * angular_velocity vector

Point Density Texture

 * Input Sockets
 * Filename
 * filename string
 * Space
 * space enum
 * Interpolation
 * interpolation enum
 * Transform
 * tfm transform
 * Vector
 * vector point
 * Output Sockets
 * Density
 * density float
 * Color
 * color color

Principled Bsdf

 * Input Sockets
 * Distribution
 * distribution enum
 * Subsurface Method
 * subsurface_method enum
 * Base Color
 * base_color color
 * Subsurface Color
 * subsurface_color color
 * Metallic
 * metallic float
 * Subsurface
 * subsurface float
 * Subsurface Radius
 * subsurface_radius vector
 * Specular
 * specular float
 * Roughness
 * roughness float
 * Specular Tint
 * specular_tint float
 * Anisotropic
 * anisotropic float
 * Sheen
 * sheen float
 * Sheen Tint
 * sheen_tint float
 * Clearcoat
 * clearcoat float
 * Clearcoat Roughness
 * clearcoat_roughness float
 * IOR
 * ior float
 * Transmission
 * transmission float
 * Transmission Roughness
 * transmission_roughness float
 * Anisotropic Rotation
 * anisotropic_rotation float
 * Emission
 * emission color
 * Emission Strength
 * emission_strength float
 * Alpha
 * alpha float
 * Normal
 * normal normal
 * Clearcoat Normal
 * clearcoat_normal normal
 * Tangent
 * tangent normal
 * SurfaceMixWeight
 * surface_mix_weight float
 * Output Sockets
 * BSDF
 * BSDF closure

Principled Hair Bsdf

 * Input Sockets
 * Parametrization
 * parametrization enum
 * Color
 * color color
 * Melanin
 * melanin float
 * Melanin Redness
 * melanin_redness float
 * Tint
 * tint color
 * Absorption Coefficient
 * absorption_coefficient vector
 * Offset
 * offset float
 * Roughness
 * roughness float
 * Radial Roughness
 * radial_roughness float
 * Coat
 * coat float
 * IOR
 * ior float
 * Random Roughness
 * random_roughness float
 * Random Color
 * random_color float
 * Random
 * random float
 * Normal
 * normal normal
 * SurfaceMixWeight
 * surface_mix_weight float
 * Output Sockets
 * BSDF
 * BSDF closure

Principled Volume

 * Input Sockets
 * Density Attribute
 * density_attribute string
 * Color Attribute
 * color_attribute string
 * Temperature Attribute
 * temperature_attribute string
 * Color
 * color color
 * Density
 * density float
 * Anisotropy
 * anisotropy float
 * Absorption Color
 * absorption_color color
 * Emission Strength
 * emission_strength float
 * Emission Color
 * emission_color color
 * Blackbody Intensity
 * blackbody_intensity float
 * Blackbody Tint
 * blackbody_tint color
 * Temperature
 * temperature float
 * VolumeMixWeight
 * volume_mix_weight float
 * Output Sockets
 * Volume
 * volume closure

Refraction Bsdf

 * Input Sockets
 * Color
 * color color
 * Normal
 * normal normal
 * SurfaceMixWeight
 * surface_mix_weight float
 * Distribution
 * distribution enum
 * Roughness
 * roughness float
 * IOR
 * IOR float
 * Output Sockets
 * BSDF
 * BSDF closure

Rgb Curves

 * Input Sockets
 * Curves
 * curves array_color
 * Min X
 * min_x float
 * Max X
 * max_x float
 * Fac
 * fac float
 * Color
 * value color
 * Output Sockets
 * Color
 * value color

Rgb Ramp

 * Input Sockets
 * Ramp
 * ramp array_color
 * Ramp Alpha
 * ramp_alpha array_float
 * Interpolate
 * interpolate boolean
 * Fac
 * fac float
 * Output Sockets
 * Color
 * color color
 * Alpha
 * alpha float

Rgb To Bw

 * Input Sockets
 * Color
 * color color
 * Output Sockets
 * Val
 * val float

Scatter Volume

 * Input Sockets
 * Color
 * color color
 * Density
 * density float
 * Anisotropy
 * anisotropy float
 * VolumeMixWeight
 * volume_mix_weight float
 * Output Sockets
 * Volume
 * volume closure

Separate Hsv

 * Input Sockets
 * Color
 * color color
 * Output Sockets
 * H
 * h float
 * S
 * s float
 * V
 * v float

Separate Rgb

 * Input Sockets
 * Image
 * color color
 * Output Sockets
 * R
 * r float
 * G
 * g float
 * B
 * b float

Separate Xyz

 * Input Sockets
 * Vector
 * vector color
 * Output Sockets
 * X
 * x float
 * Y
 * y float
 * Z
 * z float

Set Normal

 * Input Sockets
 * Direction
 * direction vector
 * Output Sockets
 * Normal
 * normal normal

Sky Texture

 * Input Sockets
 * Translation
 * tex_mapping.translation point
 * Rotation
 * tex_mapping.rotation vector
 * Scale
 * tex_mapping.scale vector
 * Min
 * tex_mapping.min vector
 * Max
 * tex_mapping.max vector
 * Use Min Max
 * tex_mapping.use_minmax boolean
 * x_mapping
 * tex_mapping.x_mapping enum
 * y_mapping
 * tex_mapping.y_mapping enum
 * z_mapping
 * tex_mapping.z_mapping enum
 * Type
 * tex_mapping.type enum
 * Projection
 * tex_mapping.projection enum
 * Type
 * sky_type enum
 * Sun Direction
 * sun_direction vector
 * Turbidity
 * turbidity float
 * Ground Albedo
 * ground_albedo float
 * Sun Disc
 * sun_disc boolean
 * Sun Size
 * sun_size float
 * Sun Intensity
 * sun_intensity float
 * Sun Elevation
 * sun_elevation float
 * Sun Rotation
 * sun_rotation float
 * Altitude
 * altitude float
 * Air
 * air_density float
 * Dust
 * dust_density float
 * Ozone
 * ozone_density float
 * Vector
 * vector point
 * Output Sockets
 * Color
 * color color

Subsurface Scattering

 * Input Sockets
 * Color
 * color color
 * Normal
 * normal normal
 * SurfaceMixWeight
 * surface_mix_weight float
 * Falloff
 * falloff enum
 * Scale
 * scale float
 * Radius
 * radius vector
 * Sharpness
 * sharpness float
 * Texture Blur
 * texture_blur float
 * Output Sockets
 * BSSRDF
 * BSSRDF closure

Tangent

 * Input Sockets
 * Direction Type
 * direction_type enum
 * Axis
 * axis enum
 * Attribute
 * attribute string
 * NormalIn
 * normal_osl normal
 * Output Sockets
 * Tangent
 * tangent normal

Texture Coordinate

 * Input Sockets
 * From Dupli
 * from_dupli boolean
 * Use Transform
 * use_transform boolean
 * Object Transform
 * ob_tfm transform
 * NormalIn
 * normal_osl normal
 * Output Sockets
 * Generated
 * generated point
 * Normal
 * normal normal
 * UV
 * UV point
 * Object
 * object point
 * Camera
 * camera point
 * Window
 * window point
 * Reflection
 * reflection normal

Toon Bsdf

 * Input Sockets
 * Color
 * color color
 * Normal
 * normal normal
 * SurfaceMixWeight
 * surface_mix_weight float
 * Component
 * component enum
 * Size
 * size float
 * Smooth
 * smooth float
 * Output Sockets
 * BSDF
 * BSDF closure

Translucent Bsdf

 * Input Sockets
 * Color
 * color color
 * Normal
 * normal normal
 * SurfaceMixWeight
 * surface_mix_weight float
 * Output Sockets
 * BSDF
 * BSDF closure

Transparent Bsdf

 * Input Sockets
 * Color
 * color color
 * SurfaceMixWeight
 * surface_mix_weight float
 * Output Sockets
 * BSDF
 * BSDF closure

Uvmap

 * Input Sockets
 * attribute
 * attribute string
 * from dupli
 * from_dupli boolean
 * Output Sockets
 * UV
 * UV point

Value

 * Input Sockets
 * Value
 * value float
 * Output Sockets
 * Value
 * value float

Vector Curves

 * Input Sockets
 * Curves
 * curves array_vector
 * Min X
 * min_x float
 * Max X
 * max_x float
 * Fac
 * fac float
 * Vector
 * value vector
 * Output Sockets
 * Vector
 * value vector

Vector Displacement

 * Input Sockets
 * Space
 * space enum
 * Attribute
 * attribute string
 * Vector
 * vector color
 * Midlevel
 * midlevel float
 * Scale
 * scale float
 * Output Sockets
 * Displacement
 * displacement vector

Vector Math

 * Input Sockets
 * Type
 * math_type enum
 * Vector1
 * vector1 vector
 * Vector2
 * vector2 vector
 * Vector3
 * vector3 vector
 * Scale
 * scale float
 * Output Sockets
 * Value
 * value float
 * Vector
 * vector vector

Vector Rotate

 * Input Sockets
 * Type
 * rotate_type enum
 * Invert
 * invert boolean
 * Vector
 * vector vector
 * Rotation
 * rotation point
 * Center
 * center point
 * Axis
 * axis vector
 * Angle
 * angle float
 * Output Sockets
 * Vector
 * vector vector

Vector Transform

 * Input Sockets
 * Type
 * transform_type enum
 * Convert From
 * convert_from enum
 * Convert To
 * convert_to enum
 * Vector
 * vector vector
 * Output Sockets
 * Vector
 * vector vector

Velvet Bsdf

 * Input Sockets
 * Color
 * color color
 * Normal
 * normal normal
 * SurfaceMixWeight
 * surface_mix_weight float
 * Sigma
 * sigma float
 * Output Sockets
 * BSDF
 * BSDF closure

Vertex Color

 * Input Sockets
 * Layer Name
 * layer_name string
 * Output Sockets
 * Color
 * color color
 * Alpha
 * alpha float

Volume Info

 * Output Sockets
 * Color
 * color color
 * Density
 * density float
 * Flame
 * flame float
 * Temperature
 * temperature float

Voronoi Texture

 * Input Sockets
 * Translation
 * tex_mapping.translation point
 * Rotation
 * tex_mapping.rotation vector
 * Scale
 * tex_mapping.scale vector
 * Min
 * tex_mapping.min vector
 * Max
 * tex_mapping.max vector
 * Use Min Max
 * tex_mapping.use_minmax boolean
 * x_mapping
 * tex_mapping.x_mapping enum
 * y_mapping
 * tex_mapping.y_mapping enum
 * z_mapping
 * tex_mapping.z_mapping enum
 * Type
 * tex_mapping.type enum
 * Projection
 * tex_mapping.projection enum
 * Dimensions
 * dimensions enum
 * Distance Metric
 * metric enum
 * Feature
 * feature enum
 * Vector
 * vector point
 * W
 * w float
 * Scale
 * scale float
 * Smoothness
 * smoothness float
 * Exponent
 * exponent float
 * Randomness
 * randomness float
 * Output Sockets
 * Distance
 * distance float
 * Color
 * color color
 * Position
 * position point
 * W
 * w float
 * Radius
 * radius float

Wave Texture

 * Input Sockets
 * Translation
 * tex_mapping.translation point
 * Rotation
 * tex_mapping.rotation vector
 * Scale
 * tex_mapping.scale vector
 * Min
 * tex_mapping.min vector
 * Max
 * tex_mapping.max vector
 * Use Min Max
 * tex_mapping.use_minmax boolean
 * x_mapping
 * tex_mapping.x_mapping enum
 * y_mapping
 * tex_mapping.y_mapping enum
 * z_mapping
 * tex_mapping.z_mapping enum
 * Type
 * tex_mapping.type enum
 * Projection
 * tex_mapping.projection enum
 * Type
 * wave_type enum
 * Bands Direction
 * bands_direction enum
 * Rings Direction
 * rings_direction enum
 * Profile
 * profile enum
 * Vector
 * vector point
 * Scale
 * scale float
 * Distortion
 * distortion float
 * Detail
 * detail float
 * Detail Scale
 * detail_scale float
 * Detail Roughness
 * detail_roughness float
 * Phase Offset
 * phase float
 * Output Sockets
 * Color
 * color color
 * Fac
 * fac float

Wavelength

 * Input Sockets
 * Wavelength
 * wavelength float
 * Output Sockets
 * Color
 * color color

White Noise Texture

 * Input Sockets
 * Dimensions
 * dimensions enum
 * Vector
 * vector point
 * W
 * w float
 * Output Sockets
 * Value
 * value float
 * Color
 * color color

Wireframe

 * Input Sockets
 * Use Pixel Size
 * use_pixel_size boolean
 * Size
 * size float
 * Output Sockets
 * Fac
 * fac float