Blender  V3.3
Macros | Functions | Variables
NOD_static_types.h File Reference

Go to the source code of this file.

Macros

#define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc)
 

Functions

 DefNode (Node, NODE_FRAME, def_frame, "FRAME", Frame, "Frame", "Collect related nodes together in a common area. Useful for organization when the re-usability of a node group is not required") DefNode(Node
 
 DefNode (Node, NODE_GROUP_INPUT, def_group_input, "GROUP_INPUT", GroupInput, "Group Input", "Expose connected data from inside a node group as inputs to its interface") DefNode(Node
 
Group Output data from inside of a node group DefNode (Node, NODE_REROUTE, 0, "REROUTE", Reroute, "Reroute", "A single-socket organization tool that supports one input and multiple outputs") DefNode(ShaderNode
 
Group Output data from inside of a node group A color picker DefNode (ShaderNode, SH_NODE_VALUE, 0, "VALUE", Value, "Value", "Used to Input numerical values to other nodes in the tree") DefNode(ShaderNode
 
Group Output data from inside of a node group A color picker Mix two input colors DefNode (ShaderNode, SH_NODE_VALTORGB, def_colorramp, "VALTORGB", ValToRGB, "ColorRamp", "Map values to colors with the use of a gradient") DefNode(ShaderNode
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value DefNode (ShaderNode, SH_NODE_SHADERTORGB, 0, "SHADERTORGB", ShaderToRGB, "Shader to RGB", "Convert rendering effect (such as light and shadow) to color. Typically used for non-photorealistic rendering, to apply additional effects on the output of BSDFs.\nNote: only supported for Eevee") DefNode(ShaderNode
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product DefNode (ShaderNode, SH_NODE_GAMMA, 0, "GAMMA", Gamma, "Gamma", "Apply a gamma correction") DefNode(ShaderNode
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color DefNode (ShaderNode, SH_NODE_MAPPING, def_sh_mapping, "MAPPING", Mapping, "Mapping", "Transform the input vector by applying translation, rotation, and scale") DefNode(ShaderNode
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input DefNode (ShaderNode, SH_NODE_CURVE_RGB, def_rgb_curve, "CURVE_RGB", RGBCurve, "RGB Curves", "Apply color corrections for each color channel") DefNode(ShaderNode
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position DefNode (ShaderNode, SH_NODE_MAP_RANGE, def_map_range, "MAP_RANGE", MapRange, "Map Range", "Remap a value from a range to a target range") DefNode(ShaderNode
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum DefNode (ShaderNode, SH_NODE_MATH, def_math, "MATH", Math, "Math", "Perform math operations") DefNode(ShaderNode
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation DefNode (ShaderNode, SH_NODE_SQUEEZE, 0, "SQUEEZE", Squeeze, "Squeeze Value", "") DefNode(ShaderNode
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative DefNode (ShaderNode, SH_NODE_SEPRGB_LEGACY, 0, "SEPRGB", SeparateRGB, "Separate RGB", "Split a color into its red, green, and blue channels (Deprecated)") DefNode(ShaderNode
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue channels (Deprecated)") DefNode(ShaderNode
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model DefNode (ShaderNode, SH_NODE_OUTPUT_MATERIAL, def_sh_output, "OUTPUT_MATERIAL", OutputMaterial, "Material Output", "Output surface material information for use in rendering") DefNode(ShaderNode
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the facing (along normal) reflection color. Energy is not conserved
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate DefNode (ShaderNode, SH_NODE_OUTPUT_LIGHT, def_sh_output, "OUTPUT_LIGHT", OutputLight, "Light Output", "Output light information to a light object") DefNode(ShaderNode
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate World Output light color information to the scene s World DefNode (ShaderNode, SH_NODE_OUTPUT_LINESTYLE, def_sh_output_linestyle,"OUTPUT_LINESTYLE", OutputLineStyle, "Line Style Output", "") DefNode(ShaderNode
 
in reality light always falls off quadratically DefNode (ShaderNode, SH_NODE_OBJECT_INFO, 0, "OBJECT_INFO", ObjectInfo, "Object Info", "Retrieve information about the object instance") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object DefNode (ShaderNode, SH_NODE_HAIR_INFO, 0, "HAIR_INFO", HairInfo, "Curves Info", "Retrieve hair curve information") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud DefNode (ShaderNode, SH_NODE_VOLUME_INFO, 0, "VOLUME_INFO", VolumeInfo, "Volume Info", "Read volume data attributes from volume grids") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated DefNode (ShaderNode, SH_NODE_WAVELENGTH, 0, "WAVELENGTH", Wavelength, "Wavelength", "Convert a wavelength value to an RGB value") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value DefNode (ShaderNode, SH_NODE_BUMP, def_sh_bump, "BUMP", Bump, "Bump", "Generate a perturbed normal from a height texture for bump mapping. Typically used for faking highly detailed surfaces") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces DefNode (ShaderNode, SH_NODE_TANGENT, def_sh_tangent, "TANGENT", Tangent, "Tangent", "Generate a tangent direction for the Anisotropic BSDF") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture DefNode (ShaderNode, SH_NODE_TEX_ENVIRONMENT, def_sh_tex_environment, "TEX_ENVIRONMENT", TexEnvironment, "Environment Texture","Sample an image file as an environment texture. Typically used to light the scene with the background node") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture DefNode (ShaderNode, SH_NODE_TEX_GRADIENT, def_sh_tex_gradient, "TEX_GRADIENT", TexGradient, "Gradient Texture", "Generate interpolated color and intensity values based on the input vector") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise DefNode (ShaderNode, SH_NODE_TEX_MAGIC, def_sh_tex_magic, "TEX_MAGIC", TexMagic, "Magic Texture", "Generate a psychedelic color texture") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise DefNode (ShaderNode, SH_NODE_TEX_MUSGRAVE, def_sh_tex_musgrave, "TEX_MUSGRAVE", TexMusgrave, "Musgrave Texture", "Generate fractal Perlin noise. Allows for greater control over how octaves are combined than the Noise Texture node") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells DefNode (ShaderNode, SH_NODE_TEX_CHECKER, def_sh_tex_checker, "TEX_CHECKER", TexChecker, "Checker Texture", "Generate a checkerboard texture") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks DefNode (ShaderNode, SH_NODE_TEX_POINTDENSITY, def_sh_tex_pointdensity,"TEX_POINTDENSITY", TexPointDensity, "Point Density", "Generate a volumetric point for each particle or vertex of another object") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes DefNode (ShaderNode, SH_NODE_VECTOR_ROTATE, def_sh_vector_rotate, "VECTOR_ROTATE", VectorRotate, "Vector Rotate", "Rotate a vector around a pivot point (center)") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space DefNode (ShaderNode, SH_NODE_SEPHSV_LEGACY, 0, "SEPHSV", SeparateHSV, "Separate HSV", "Split a color into its hue, saturation, and value channels") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels DefNode (ShaderNode, SH_NODE_UVMAP, def_sh_uvmap, "UVMAP", UVMap, "UV Map", "Retrieve a UV map from the geometry, or the default fallback if none is specified") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified DefNode (ShaderNode, SH_NODE_UVALONGSTROKE, def_sh_uvalongstroke, "UVALONGSTROKE", UVAlongStroke, "UV Along Stroke", "") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components DefNode (ShaderNode, SH_NODE_COMBXYZ, 0, "COMBXYZ", CombineXYZ, "Combine XYZ", "Create a vector from X, Y, and Z components") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders DefNode (ShaderNode, SH_NODE_DISPLACEMENT, def_sh_displacement, "DISPLACEMENT", Displacement, "Displacement", "Displace the surface along the surface normal") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction DefNode (ShaderNode, SH_NODE_TEX_IES, def_sh_tex_ies, "TEX_IES", TexIES, "IES Texture", "Used to match real world lights with IES files, which store the directional intensity distribution of light sources") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed DefNode (ShaderNode, SH_NODE_OUTPUT_AOV, def_sh_output_aov, "OUTPUT_AOV", OutputAOV, "AOV Output", "Arbitrary Output Variables.\nProvide custom render passes for arbitrary shader node outputs") DefNode(ShaderNode
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed Float Map an input float to a curve and outputs a float value DefNode (ShaderNode, SH_NODE_COMBINE_COLOR, def_sh_combsep_color, "COMBINE_COLOR", CombineColor, "Combine Color", "Create a color from individual components using multiple models") DefNode(ShaderNode
 

Variables

 NODE_GROUP
 
 def_group
 
 GROUP
 
 Group
 
 NODE_GROUP_OUTPUT
 
 def_group_output
 
 GROUP_OUTPUT
 
 GroupOutput
 
Group Output
 
Group Output data from inside of a node group SH_NODE_RGB
 
Group Output data from inside of a node group RGB
 
Group Output data from inside of a node group A color picker SH_NODE_MIX_RGB
 
Group Output data from inside of a node group A color picker def_mix_rgb
 
Group Output data from inside of a node group A color picker MIX_RGB
 
Group Output data from inside of a node group A color picker MixRGB
 
Group Output data from inside of a node group A color picker Mix two input colors SH_NODE_RGBTOBW
 
Group Output data from inside of a node group A color picker Mix two input colors RGBTOBW
 
Group Output data from inside of a node group A color picker Mix two input colors RGBToBW
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to BW
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value SH_NODE_NORMAL
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value NORMAL
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Normal
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product SH_NODE_BRIGHTCONTRAST
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product BRIGHTCONTRAST
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product BrightContrast
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Contrast
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color SH_NODE_CURVE_VEC
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color def_vector_curve
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color CURVE_VEC
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color VectorCurve
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Curves
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to curves
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input SH_NODE_CAMERA
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input CAMERA
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input CameraData
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Data
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position SH_NODE_CLAMP
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position def_clamp
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position CLAMP
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum SH_NODE_VECTOR_MATH
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum def_vector_math
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum VECT_MATH
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum VectorMath
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Math
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation SH_NODE_INVERT
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation INVERT
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invertcolor
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative SH_NODE_COMBRGB_LEGACY
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative COMBRGB
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative CombineRGB
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its red
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its green
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue SH_NODE_HUE_SAT
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue HUE_SAT
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue HueSaturation
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Value
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model SH_NODE_EEVEE_SPECULAR
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model EEVEE_SPECULAR
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model EeveeSpecular
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular BSDF
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of metallic
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate SH_NODE_OUTPUT_WORLD
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate def_sh_output
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate OUTPUT_WORLD
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate OutputWorld
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate World Output light color information to the scene s World SH_NODE_FRESNEL
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate World Output light color information to the scene s World FRESNEL
 
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate World Output light color information to the scene s World Fresnel
 
in reality light always falls off quadratically SH_NODE_PARTICLE_INFO
 
in reality light always falls off quadratically PARTICLE_INFO
 
in reality light always falls off quadratically ParticleInfo
 
in reality light always falls off quadratically Particle Info
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object instance
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object SH_NODE_POINT_INFO
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object POINT_INFO
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object PointInfo
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud SH_NODE_WIREFRAME
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud def_sh_tex_wireframe
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud WIREFRAME
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Wireframe
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles nNote
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated SH_NODE_BLACKBODY
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated BLACKBODY
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Blackbody
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value SH_NODE_NORMAL_MAP
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value def_sh_normal_map
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value NORMAL_MAP
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value NormalMap
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Map
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces SH_NODE_SCRIPT
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces def_sh_script
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces SCRIPT
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Script
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block SH_NODE_TEX_IMAGE
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block def_sh_tex_image
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block TEX_IMAGE
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block TexImage
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Texture
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture SH_NODE_TEX_SKY
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture def_sh_tex_sky
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture TEX_SKY
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture TexSky
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture SH_NODE_TEX_NOISE
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture def_sh_tex_noise
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture TEX_NOISE
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture TexNoise
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise SH_NODE_TEX_WAVE
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise def_sh_tex_wave
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise TEX_WAVE
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise TexWave
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise SH_NODE_TEX_VORONOI
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise def_sh_tex_voronoi
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise TEX_VORONOI
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise TexVoronoi
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as stones
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as water
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells SH_NODE_TEX_BRICK
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells def_sh_tex_brick
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells TEX_BRICK
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells TexBrick
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks SH_NODE_TEX_COORD
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks def_sh_tex_coord
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks TEX_COORD
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks TexCoord
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Coordinate
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes SH_NODE_VECT_TRANSFORM
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes def_sh_vect_transform
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes VECT_TRANSFORM
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes VectorTransform
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Transform
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a vector
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a point
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between world
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between camera
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space SH_NODE_COMBHSV_LEGACY
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space COMBHSV
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space CombineHSV
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine HSV
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its hue
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its saturation
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels SH_NODE_VERTEX_COLOR
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels def_sh_vertex_color
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels VERTEX_COLOR
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels VertexColor
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Attribute
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color attribute
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified SH_NODE_SEPXYZ
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified SEPXYZ
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified SeparateXYZ
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate XYZ
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its X
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its Y
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components SH_NODE_BEVEL
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components def_sh_bevel
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components BEVEL
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Bevel
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders SH_NODE_VECTOR_DISPLACEMENT
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders def_sh_vector_displacement
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders VECTOR_DISPLACEMENT
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders VectorDisplacement
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displacement
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction SH_NODE_TEX_WHITE_NOISE
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction def_sh_tex_white_noise
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction TEX_WHITE_NOISE
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction TexWhiteNoise
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Noise
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed SH_NODE_CURVE_FLOAT
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed def_float_curve
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed CURVE_FLOAT
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed FloatCurve
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed Float Curve
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed Float Map an input float to a curve and outputs a float value SH_NODE_SEPARATE_COLOR
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed Float Map an input float to a curve and outputs a float value def_sh_combsep_color
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed Float Map an input float to a curve and outputs a float value SEPARATE_COLOR
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed Float Map an input float to a curve and outputs a float value SeparateColor
 
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed Float Map an input float to a curve and outputs a float value Separate Color
 

Macro Definition Documentation

◆ DefNode

#define DefNode (   Category,
  ID,
  DefFunc,
  EnumName,
  StructName,
  UIName,
  UIDesc 
)

Definition at line 14 of file NOD_static_types.h.

Function Documentation

◆ channels()

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue channels ( Deprecated  )

Referenced by accessor_get_image_callback(), all_strips_from_context(), animsys_evaluate_nla_domain(), libmv::internal::LookupWarpGrid::Apply(), BKE_image_stamp_buf(), BKE_volume_grid_dense_floats(), BLF_thumb_preview(), bssrdf_num_channels(), collection_filter_rendered_strips(), color3ubv_from_seq(), colormanagement_transform_ex(), FallbackImpl::cpuProcessorApply(), FallbackImpl::cpuProcessorApply_predivide(), createTransSeqImageData(), curve_mapping_apply_pixel(), display_buffer_apply_get_linear_buffer(), display_buffer_init_handle(), libmv::CameraIntrinsics::DistortBuffer(), do_adjustment_impl(), do_display_buffer_apply_thread(), do_multicam(), do_processor_transform_thread(), do_render_strip_seqbase(), draw_color_strip_band(), draw_render_result_ensure_pass_cb(), draw_seq_background(), draw_seq_strip(), draw_seq_text_overlay(), draw_sequence_extensions_overlay(), drawmeta_contents(), drw_command_clear(), DRW_shgroup_clear_framebuffer(), ED_image_draw_info(), exr_channels_in_multi_part_file(), exr_is_half_float(), exr_print_filecontents(), exr_rgba_channelname(), fill_mapping(), fwritecolrs(), gizmo2d_calc_bounds(), gizmo2d_calc_rotation(), gizmo2d_calc_transform_orientation(), gizmo2d_calc_transform_pivot(), GPU_framebuffer_read_color(), GPU_frontbuffer_read_pixels(), image_exr_from_scene_linear_to_output(), image_get_render_result(), imb_addrectfloatImBuf(), imb_alloc_pixels(), IMB_allocFromBuffer(), IMB_allocFromBufferOwn(), IMB_colormanagement_colorspace_to_scene_linear(), IMB_colormanagement_processor_apply(), IMB_colormanagement_processor_apply_byte(), IMB_colormanagement_processor_apply_pixel(), IMB_colormanagement_transform(), IMB_colormanagement_transform_byte(), IMB_colormanagement_transform_byte_threaded(), IMB_colormanagement_transform_from_byte(), IMB_colormanagement_transform_from_byte_threaded(), IMB_colormanagement_transform_threaded(), IMB_display_buffer_transform_apply(), IMB_exr_begin_read(), imb_exr_is_multilayer_file(), imb_exr_multilayer_parse_channels_from_file(), imb_exr_type_by_channels(), imb_filterN(), imb_loadpng(), IMB_premultiply_rect_float(), imb_save_openexr_float(), imb_save_openexr_half(), imb_stereo3d_data_init(), IMB_stereo3d_from_rect(), IMB_stereo3d_from_rectf(), imb_stereo3d_read_anaglyph(), imb_stereo3d_read_interlace(), imb_stereo3d_read_sidebyside(), imb_stereo3d_read_topbottom(), imb_stereo3d_squeeze_rect(), imb_stereo3d_squeeze_rectf(), imb_stereo3d_write_anaglyph(), imb_stereo3d_write_interlace(), imb_stereo3d_write_sidebyside(), imb_stereo3d_write_topbottom(), IMB_unpremultiply_rect_float(), libmv_byteBufferToFloatImage(), libmv_cameraIntrinsicsDistortByte(), libmv_cameraIntrinsicsDistortFloat(), libmv_cameraIntrinsicsUndistortByte(), libmv_cameraIntrinsicsUndistortFloat(), libmv_detectFeaturesByte(), libmv_detectFeaturesFloat(), libmv_floatBufferToFloatImage(), libmv_samplePlanarPatchByte(), libmv_samplePlanarPatchFloat(), BlenderImageLoader::load_pixels(), nla_eval_domain_action(), nla_eval_domain_strips(), nladata_flush_channels(), nlasnapshot_blend_strip(), nlasnapshot_blend_strip_get_inverted_lower_snapshot(), nlasnapshot_blend_strip_no_blend(), nlasnapshot_from_action(), nlastrip_evaluate(), nlastrip_evaluate_actionclip(), nlastrip_evaluate_meta(), nlastrip_evaluate_transition(), DenoiseImage::parse_channels(), partial_buffer_update_rect(), processor_transform_apply_threaded(), processor_transform_init_handle(), pygpu_framebuffer_read_color(), query_snap_targets(), RE_create_render_pass(), RE_engine_add_pass(), RE_engine_register_pass(), render_layer_add_pass(), libmv::SamplePattern(), screen_ctx_selected_editable_sequences(), selected_strips_from_context(), seq_box_select_seq_from_preview(), SEQ_channel_get_by_index(), SEQ_channel_name_get(), SEQ_channels_displayed_set(), SEQ_channels_ensure(), SEQ_channels_free(), SEQ_get_channels_by_seq(), seq_get_shown_sequences(), seq_get_strip_pivot_median(), seq_get_text_strip_cb(), SEQ_get_topmost_sequence(), seq_prefetch_frames(), seq_prefetch_must_skip_frame(), seq_prefetch_scene_strip_is_rendered(), SEQ_query_rendered_strips(), SEQ_render_give_ibuf(), seq_render_give_ibuf_seqbase(), SEQ_render_is_muted(), seq_render_strip_stack(), seq_select_seq_from_preview(), SEQ_time_find_next_prev_edit(), SEQ_transform_is_locked(), seq_update_muting_recursive(), SeqTransInfo(), sequencer_draw_preview(), sequencer_drop_copy(), sequencer_mute_exec(), sequencer_snap_exec(), sequencer_unmute_exec(), studiolight_multilayer_convert_pass(), ColorSpaceManager::to_scene_linear(), libmv::CameraIntrinsics::UndistortBuffer(), and volume_grid_cache_get().

◆ DefNode() [1/37]

DefNode ( Node  ,
NODE_FRAME  ,
def_frame  ,
"FRAME"  ,
Frame  ,
"Frame"  ,
"Collect related nodes together in a common area. Useful for organization when the re-usability of a node group is not required"   
)

◆ DefNode() [2/37]

DefNode ( Node  ,
NODE_GROUP_INPUT  ,
def_group_input  ,
"GROUP_INPUT"  ,
GroupInput  ,
"Group Input"  ,
"Expose connected data from inside a node group as inputs to its interface"   
)

◆ DefNode() [3/37]

Group Output data from inside of a node group DefNode ( Node  ,
NODE_REROUTE  ,
,
"REROUTE"  ,
Reroute  ,
"Reroute"  ,
"A single-socket organization tool that supports one input and multiple outputs  
)

◆ DefNode() [4/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value DefNode ( ShaderNode  ,
SH_NODE_BUMP  ,
def_sh_bump  ,
"BUMP"  ,
Bump  ,
"Bump"  ,
"Generate a perturbed normal from a height texture for bump mapping. Typically used for faking highly detailed surfaces"   
)

◆ DefNode() [5/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed Float Map an input float to a curve and outputs a float value DefNode ( ShaderNode  ,
SH_NODE_COMBINE_COLOR  ,
def_sh_combsep_color  ,
"COMBINE_COLOR"  ,
CombineColor  ,
"Combine Color ,
"Create a color from individual components using multiple models"   
)

◆ DefNode() [6/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components DefNode ( ShaderNode  ,
SH_NODE_COMBXYZ  ,
,
"COMBXYZ"  ,
CombineXYZ  ,
"Combine XYZ ,
"Create a vector from  X,
Y  ,
and Z components"   
)

◆ DefNode() [7/37]

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input DefNode ( ShaderNode  ,
SH_NODE_CURVE_RGB  ,
def_rgb_curve  ,
"CURVE_RGB"  ,
RGBCurve  ,
"RGB Curves ,
"Apply color corrections for each color channel"   
)

◆ DefNode() [8/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders DefNode ( ShaderNode  ,
SH_NODE_DISPLACEMENT  ,
def_sh_displacement  ,
"DISPLACEMENT"  ,
Displacement  ,
"Displacement"  ,
"Displace the surface along the surface normal  
)

◆ DefNode() [9/37]

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product DefNode ( ShaderNode  ,
SH_NODE_GAMMA  ,
,
"GAMMA"  ,
Gamma  ,
"Gamma"  ,
"Apply a gamma correction"   
)

◆ DefNode() [10/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object DefNode ( ShaderNode  ,
SH_NODE_HAIR_INFO  ,
,
"HAIR_INFO"  ,
HairInfo  ,
"Curves Info ,
"Retrieve hair curve information"   
)

◆ DefNode() [11/37]

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position DefNode ( ShaderNode  ,
SH_NODE_MAP_RANGE  ,
def_map_range  ,
"MAP_RANGE"  ,
MapRange  ,
"Map Range"  ,
"Remap a value from a range to a target range"   
)

◆ DefNode() [12/37]

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color DefNode ( ShaderNode  ,
SH_NODE_MAPPING  ,
def_sh_mapping  ,
"MAPPING"  ,
Mapping  ,
"Mapping"  ,
"Transform the input vector by applying  translation,
rotation  ,
and scale"   
)

◆ DefNode() [13/37]

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum DefNode ( ShaderNode  ,
SH_NODE_MATH  ,
def_math  ,
"MATH"  ,
Math  ,
"Math"  ,
"Perform math operations"   
)

◆ DefNode() [14/37]

in reality light always falls off quadratically DefNode ( ShaderNode  ,
SH_NODE_OBJECT_INFO  ,
,
"OBJECT_INFO"  ,
ObjectInfo  ,
"Object Info ,
"Retrieve information about the object instance  
)

◆ DefNode() [15/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed DefNode ( ShaderNode  ,
SH_NODE_OUTPUT_AOV  ,
def_sh_output_aov  ,
"OUTPUT_AOV"  ,
OutputAOV  ,
"AOV Output ,
"Arbitrary Output Variables.\nProvide custom render passes for arbitrary shader node outputs  
)

◆ DefNode() [16/37]

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate DefNode ( ShaderNode  ,
SH_NODE_OUTPUT_LIGHT  ,
def_sh_output  ,
"OUTPUT_LIGHT"  ,
OutputLight  ,
"Light Output ,
"Output light information to a light object"   
)

◆ DefNode() [17/37]

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate World Output light color information to the scene s World DefNode ( ShaderNode  ,
SH_NODE_OUTPUT_LINESTYLE  ,
def_sh_output_linestyle  ,
"OUTPUT_LINESTYLE"  ,
OutputLineStyle  ,
"Line Style Output ,
""   
)

◆ DefNode() [18/37]

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model DefNode ( ShaderNode  ,
SH_NODE_OUTPUT_MATERIAL  ,
def_sh_output  ,
"OUTPUT_MATERIAL"  ,
OutputMaterial  ,
"Material Output ,
"Output surface material information for use in rendering"   
)

◆ DefNode() [19/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space DefNode ( ShaderNode  ,
SH_NODE_SEPHSV_LEGACY  ,
,
"SEPHSV"  ,
SeparateHSV  ,
"Separate HSV ,
"Split a color into its  hue,
saturation  ,
and value channels  
)

◆ DefNode() [20/37]

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative DefNode ( ShaderNode  ,
SH_NODE_SEPRGB_LEGACY  ,
,
"SEPRGB"  ,
SeparateRGB  ,
"Separate RGB ,
"Split a color into its  red,
green  ,
and blue channels(Deprecated)"   
)

◆ DefNode() [21/37]

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value DefNode ( ShaderNode  ,
SH_NODE_SHADERTORGB  ,
,
"SHADERTORGB"  ,
ShaderToRGB  ,
"Shader to RGB ,
"Convert rendering effect (such as light and shadow) to color. Typically used for non-photorealistic  rendering,
to apply additional effects on the output of BSDFs.\nNote:only supported for Eevee"   
)

◆ DefNode() [22/37]

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation DefNode ( ShaderNode  ,
SH_NODE_SQUEEZE  ,
,
"SQUEEZE"  ,
Squeeze  ,
"Squeeze Value ,
""   
)

◆ DefNode() [23/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces DefNode ( ShaderNode  ,
SH_NODE_TANGENT  ,
def_sh_tangent  ,
"TANGENT"  ,
Tangent  ,
"Tangent"  ,
"Generate a tangent direction for the Anisotropic BSDF  
)

◆ DefNode() [24/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells DefNode ( ShaderNode  ,
SH_NODE_TEX_CHECKER  ,
def_sh_tex_checker  ,
"TEX_CHECKER"  ,
TexChecker  ,
"Checker Texture ,
"Generate a checkerboard texture"   
)

◆ DefNode() [25/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture DefNode ( ShaderNode  ,
SH_NODE_TEX_ENVIRONMENT  ,
def_sh_tex_environment  ,
"TEX_ENVIRONMENT"  ,
TexEnvironment  ,
"Environment Texture ,
"Sample an image file as an environment texture. Typically used to light the scene with the background node  
)

◆ DefNode() [26/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture DefNode ( ShaderNode  ,
SH_NODE_TEX_GRADIENT  ,
def_sh_tex_gradient  ,
"TEX_GRADIENT"  ,
TexGradient  ,
"Gradient Texture ,
"Generate interpolated color and intensity values based on the input vector  
)

◆ DefNode() [27/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction DefNode ( ShaderNode  ,
SH_NODE_TEX_IES  ,
def_sh_tex_ies  ,
"TEX_IES"  ,
TexIES  ,
"IES Texture ,
"Used to match real world lights with IES  files,
which store the directional intensity distribution of light sources"   
)

◆ DefNode() [28/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise DefNode ( ShaderNode  ,
SH_NODE_TEX_MAGIC  ,
def_sh_tex_magic  ,
"TEX_MAGIC"  ,
TexMagic  ,
"Magic Texture ,
"Generate a psychedelic color texture"   
)

◆ DefNode() [29/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise DefNode ( ShaderNode  ,
SH_NODE_TEX_MUSGRAVE  ,
def_sh_tex_musgrave  ,
"TEX_MUSGRAVE"  ,
TexMusgrave  ,
"Musgrave Texture ,
"Generate fractal Perlin noise. Allows for greater control over how octaves are combined than the Noise Texture node  
)

◆ DefNode() [30/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks DefNode ( ShaderNode  ,
SH_NODE_TEX_POINTDENSITY  ,
def_sh_tex_pointdensity  ,
"TEX_POINTDENSITY"  ,
TexPointDensity  ,
"Point Density"  ,
"Generate a volumetric point for each particle or vertex of another object"   
)

◆ DefNode() [31/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified DefNode ( ShaderNode  ,
SH_NODE_UVALONGSTROKE  ,
def_sh_uvalongstroke  ,
"UVALONGSTROKE"  ,
UVAlongStroke  ,
"UV Along Stroke"  ,
""   
)

◆ DefNode() [32/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels DefNode ( ShaderNode  ,
SH_NODE_UVMAP  ,
def_sh_uvmap  ,
"UVMAP"  ,
UVMap  ,
"UV Map ,
"Retrieve a UV map from the  geometry,
or the default fallback if none is specified"   
)

◆ DefNode() [33/37]

Group Output data from inside of a node group A color picker Mix two input colors DefNode ( ShaderNode  ,
SH_NODE_VALTORGB  ,
def_colorramp  ,
"VALTORGB"  ,
ValToRGB  ,
"ColorRamp"  ,
"Map values to colors with the use of a gradient"   
)

◆ DefNode() [34/37]

Group Output data from inside of a node group A color picker DefNode ( ShaderNode  ,
SH_NODE_VALUE  ,
,
"VALUE"  ,
Value  ,
"Value"  ,
"Used to Input numerical values to other nodes in the tree  
)

◆ DefNode() [35/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes DefNode ( ShaderNode  ,
SH_NODE_VECTOR_ROTATE  ,
def_sh_vector_rotate  ,
"VECTOR_ROTATE"  ,
VectorRotate  ,
"Vector Rotate"  ,
"Rotate a vector around a pivot point (center)"   
)

◆ DefNode() [36/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud DefNode ( ShaderNode  ,
SH_NODE_VOLUME_INFO  ,
,
"VOLUME_INFO"  ,
VolumeInfo  ,
"Volume Info ,
"Read volume data attributes from volume grids"   
)

◆ DefNode() [37/37]

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated DefNode ( ShaderNode  ,
SH_NODE_WAVELENGTH  ,
,
"WAVELENGTH"  ,
Wavelength  ,
"Wavelength"  ,
"Convert a wavelength value to an RGB value"   
)

◆ facing()

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the facing ( along  normal)

Referenced by NODE_DEFINE().

Variable Documentation

◆ Attribute

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Attribute

◆ attribute

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color attribute

Definition at line 112 of file NOD_static_types.h.

Referenced by attr_create_random_per_island(), UVMapNode::attributes(), AttributeNode::attributes(), NormalMapNode::attributes(), TangentNode::attributes(), VectorDisplacementNode::attributes(), blender::io::serialize::convert_to_json(), blender::nodes::node_geo_delete_geometry_cc::copy_attributes(), blender::nodes::node_geo_delete_geometry_cc::copy_attributes_based_on_map(), blender::nodes::node_geo_delete_geometry_cc::copy_attributes_based_on_mask(), blender::bke::copy_with_removed_points(), ImageTextureNode::cull_tiles(), curves_batch_ensure_attribute(), blender::nodes::node_geo_curve_to_points_cc::ensure_point_attribute(), blender::nodes::node_geo_extrude_mesh_cc::extrude_mesh_edges(), blender::nodes::node_geo_extrude_mesh_cc::extrude_mesh_face_regions(), blender::nodes::node_geo_extrude_mesh_cc::extrude_mesh_vertices(), blender::ed::spreadsheet::GeometryDataSource::get_column_values(), blender::bke::CustomDataAttributes::get_for_read(), blender::bke::IDAttributeFieldInput::get_varray_for_context(), internal_dependencies_panel_draw(), blender::bke::AttributeAccessor::lookup(), blender::bke::attribute_accessor_functions::lookup(), blender::nodes::geometry_nodes_eval_log::NodeLog::lookup_available_attributes(), blender::bke::MutableAttributeAccessor::lookup_for_write(), blender::bke::attribute_accessor_functions::lookup_for_write(), blender::bke::MutableAttributeAccessor::lookup_or_add_for_write_only_span(), blender::bke::MutableAttributeAccessor::lookup_or_add_for_write_span(), blender::nodes::node_geo_flip_faces_cc::mesh_flip_faces(), blender::ed::space_node::named_attribute_tooltip(), NODE_DEFINE(), blender::geometry::preprocess_curves(), blender::geometry::preprocess_meshes(), blender::geometry::preprocess_pointclouds(), AttributeSet::remove(), Spline::reverse(), blender::nodes::node_geo_extrude_mesh_cc::save_selection_as_attribute(), blender::compositor::MovieClipAttributeOperation::set_attribute(), store_computed_output_attributes(), blender::geometry::subdivide_curves(), thread::thread(), blender::nodes::node_geo_store_named_attribute_cc::try_capture_field_on_geometry(), blender::bke::DynamicPointAttributeProvider::try_get_for_read(), blender::bke::DynamicPointAttributeProvider::try_get_for_write(), and blender::io::obj::OBJWriter::write_vertex_coords().

◆ BEVEL

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components BEVEL

Definition at line 116 of file NOD_static_types.h.

◆ Bevel

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Bevel

Definition at line 116 of file NOD_static_types.h.

Referenced by modifier_type_init().

◆ BLACKBODY

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated BLACKBODY

Definition at line 89 of file NOD_static_types.h.

◆ Blackbody

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Blackbody

Definition at line 89 of file NOD_static_types.h.

◆ BRIGHTCONTRAST

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product BRIGHTCONTRAST

Definition at line 34 of file NOD_static_types.h.

◆ BrightContrast

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product BrightContrast

Definition at line 34 of file NOD_static_types.h.

Referenced by sequence_modifier_type_info_init().

◆ BSDF

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular BSDF

Definition at line 50 of file NOD_static_types.h.

Referenced by NODE_DEFINE(), and svm_node_closure_bsdf().

◆ BW

Group Output data from inside of a node group A color picker Mix two input colors RGB to BW

Definition at line 30 of file NOD_static_types.h.

◆ CAMERA

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input CAMERA

Definition at line 38 of file NOD_static_types.h.

◆ camera

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between camera

Definition at line 108 of file NOD_static_types.h.

Referenced by bc_getSceneCameraAction(), BKE_camera_multiview_model_matrix(), BKE_camera_multiview_model_matrix_scaled(), BKE_camera_multiview_params(), BKE_camera_multiview_render(), BKE_camera_multiview_shift_x(), BKE_camera_multiview_spherical_stereo(), BKE_camera_multiview_view_matrix(), BKE_camera_multiview_window_matrix(), BKE_camera_view_frame(), BKE_camera_view_frame_ex(), BKE_image_stamp_buf(), BKE_render_result_stamp_info(), BKE_scene_camera_switch_update(), BKE_stamp_info_callback(), BKE_tracking_camera_to_blender(), BKE_tracking_distort_frame(), BKE_tracking_distort_v2(), BKE_tracking_distortion_new(), BKE_tracking_distortion_update(), BKE_tracking_get_projection_matrix(), BKE_tracking_undistort_frame(), BKE_tracking_undistort_v2(), Freestyle::BlenderStrokeRenderer::BlenderStrokeRenderer(), BLI_uvproject_camera_info(), blo_do_versions_270(), BLO_update_defaults_startup_blend(), blender::deg::DepsgraphNodeBuilder::build_camera(), blender::deg::DepsgraphRelationBuilder::build_camera(), blender::deg::DepsgraphNodeBuilder::build_object_data_camera(), blender::deg::DepsgraphRelationBuilder::build_object_data_camera(), camera_foreach_id(), camera_model_matrix(), camera_multiview_advanced(), blender::io::usd::camera_sensor_size_for_render(), camera_stereo3d_model_matrix(), camera_stereo3d_shift_x(), camera_view3d_reconstruction(), check_undistortion_cache_flags(), check_valid_camera_multiview(), DocumentImporter::create_camera_object(), depthdropper_init(), blender::compositor::ConvertDepthToRadiusOperation::determine_focal_distance(), distortion_model_parameters_from_options(), distortion_model_parameters_from_tracking(), do_render_engine(), do_set_scale(), do_versions_after_linking_280(), do_versions_after_linking_cycles(), blender::io::usd::USDCameraWriter::do_write(), draw_frame_curves(), draw_marker_name(), ed_marker_move_apply(), ed_marker_select(), ed_marker_select_exec(), ED_update_for_newframe(), ED_view3d_draw_offscreen_imbuf(), ED_view3d_draw_offscreen_imbuf_simple(), ED_view3d_smooth_view_undo_begin(), ED_view3d_smooth_view_undo_end(), EEVEE_depth_of_field_init(), EEVEE_effects_init(), eevee_engine_init(), libmv::EuclideanBundleCommonIntrinsics(), libmv::EuclideanIntersect(), libmv::EuclideanScaleToUnity(), BCAnimationCurve::get_animation_name(), AnimationImporter::get_animation_type(), get_aspect_ratio(), get_camera_with_movieclip(), GPENCIL_render_init(), blender::compositor::ConvertDepthToRadiusOperation::init_execution(), libmv::EuclideanReconstruction::InsertCamera(), libmv::ProjectiveReconstruction::InsertCamera(), libmv::InternalReprojectionError(), blender::io::alembic::ABCCameraWriter::is_supported(), blender::io::usd::USDCameraWriter::is_supported(), libmv_reprojectionCameraForImage(), libmv_reprojectionErrorForImage(), libmv_reprojectionErrorForTrack(), lineart_create_render_buffer(), lineart_main_load_geometries(), NODE_DEFINE(), object_preview_camera_create(), libmv::ProjectiveIntersect(), put_postprocessed_frame_to_cache(), RE_engine_get_camera_model_matrix(), RE_engine_get_camera_shift_x(), RE_engine_get_spherical_stereo(), RE_GetCamera(), RE_GetCameraModelMatrix(), RE_GetCameraWindow(), RE_PreviewRender(), HdCyclesFileReader::read(), Freestyle::BlenderStrokeRenderer::RenderScene(), screen_opengl_render_doit(), screen_opengl_views_setup(), select_marker_camera_switch(), seq_render_scene_strip(), set_axis(), blender::compositor::ConvertDepthToRadiusOperation::set_camera_object(), set_origin_exec(), set_plane_exec(), solve_camera_freejob(), stampdata(), tracking_cameraIntrinscisOptionsFromTracking(), tracking_scale_reconstruction(), tracking_trackingCameraFromIntrinscisOptions(), AnimationImporter::translate_Animations(), ShaderParameters::update(), uv_from_view_exec(), uv_from_view_invoke(), view3d_stereo3d_setup(), view3d_stereo3d_setup_offscreen(), WIDGETGROUP_camera_poll(), workbench_dof_engine_init(), DocumentImporter::write_node(), and DocumentImporter::writeCamera().

◆ CameraData

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input CameraData

Definition at line 38 of file NOD_static_types.h.

◆ CLAMP

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position CLAMP

Definition at line 40 of file NOD_static_types.h.

Referenced by _bli_array_iter_spiral_square(), actcon_get_tarmat(), angle_signed_on_axis_normalized_v3v3_v3(), anim_set_efra_exec(), anim_set_sfra_exec(), annotation_stroke_newfrombuffer(), apply_scale_factor_clamp(), apply_stroke_envelope(), applyEdgeSlide(), applyGPOpacity(), applyToSphere(), applyVertSlide(), area_actionzone_refresh_xy(), area_move_apply_do(), area_snap_calc_location(), basic_integrate(), bicubic_interpolation(), BKE_brush_curve_strength_clamped(), BKE_brush_sample_masktex(), BKE_brush_size_set(), BKE_colorband_evaluate(), BKE_defvert_normalize(), BKE_defvert_normalize_lock_map(), BKE_defvert_normalize_lock_single(), BKE_defvert_normalize_subset(), BKE_gpencil_stroke_stretch(), BKE_gpencil_stroke_subdivide(), BKE_keyblock_move(), BKE_maskrasterize_handle_sample(), BKE_mesh_remap_calc_edges_from_mesh(), BKE_mesh_remap_calc_polys_from_mesh(), BKE_mesh_remap_calc_verts_from_mesh(), BKE_mesh_validate_arrays(), BKE_pchan_bbone_deform_segment_index(), BKE_pose_blend_read_data(), blf_glyph_set_variation_float(), BLI_system_thread_count(), bm_decim_edge_collapse(), bm_face_split_edge_find(), boxsample(), BPy_IDArray_ass_slice(), BPy_IDArray_slice(), brush_average_apply(), brush_draw_apply(), brush_smear_apply(), brush_tint_apply(), buf_rectfill_area(), build_concurrent(), build_sequential(), buildNormal(), calc_min_radius_v3v3(), blender::nodes::node_shader_math_cc::ClampWrapperFunction::call(), change_character_exec(), change_frame(), change_spacing_exec(), blender::compositor::MathBaseOperation::clamp_if_needed(), clamp_v2(), clamp_v2_v2v2(), clamp_v3(), clamp_v3_v3v3(), clamp_v4(), clamp_v4_v4v4(), blender::compositor::MathBaseOperation::clamp_when_enabled(), collision_newton_rhapson(), collision_response(), Color_ass_slice(), color_balance_fl_lgg(), color_balance_fl_sop(), Color_channel_hsv_set(), Color_slice(), colorfn(), compute_scale_factor(), cp_shade_color3ub(), create_jitter_texture(), curve_blend_read_data(), D(), data_transfer_interp_char(), deformStroke(), displaceModifier_do_task(), displayed_channel_range_get(), blender::draw::distort_remap(), do_enhance_details_brush_task_cb_ex(), do_guides(), do_kink(), do_kink_spiral_deform(), do_particle_interpolation(), do_projectpaint_thread(), do_smooth_brush_task_cb_ex(), do_weight_paint_normalize_all_locked(), do_weight_paint_vertex_multi(), do_weight_paint_vertex_single(), draw_frustum_bound_sphere_calc(), draw_seq_fcurve_overlay(), dynamic_paint_effect_drip_cb(), dynamic_paint_effect_spread_cb(), dynamic_paint_find_island_border(), dynamic_paint_output_surface_image_displace_cb(), dynamic_paint_output_surface_image_wave_cb(), dynamic_paint_paint_mesh_cell_point_cb_ex(), dynamic_paint_paint_single_point_cb_ex(), dynamic_paint_surface_pre_step_cb(), dynamicPaint_doSmudge(), dynamicPaint_doWaveStep(), dynamicPaint_frameUpdate(), dynamicPaint_mixPaintColors(), dynamicPaint_prepareEffectStep(), dynamicPaint_updatePointData(), ED_curve_join_objects_exec(), ED_fileselect_layout_offset_rect(), ED_region_blend_alpha(), ED_region_grid_draw(), ED_space_clip_color_sample(), ED_space_image_color_sample(), ED_space_node_color_sample(), ED_view3d_camera_view_pan(), ED_view3d_camera_view_zoom_scale(), edbm_bevel_mouse_set_value(), edbm_bevel_numinput_set_value(), edge_pan_speed(), EEVEE_bloom_init(), EEVEE_lightbake_filter_glossy(), EEVEE_shadows_init(), encode_2f_to_float(), Euler_ass_slice(), Euler_slice(), eval_table(), blender::draw::evaluate_vertex_weight(), blender::compositor::ConvolutionEdgeFilterOperation::execute_pixel(), blender::compositor::ConvolutionFilterOperation::execute_pixel(), blender::compositor::DespeckleOperation::execute_pixel(), blender::compositor::GaussianBokehBlurOperation::execute_pixel(), blender::compositor::BoxMaskOperation::execute_pixel_sampled(), blender::compositor::DisplaceSimpleOperation::execute_pixel_sampled(), blender::compositor::EllipseMaskOperation::execute_pixel_sampled(), blender::compositor::HueSaturationValueCorrectOperation::execute_pixel_sampled(), blender::compositor::MapRangeOperation::execute_pixel_sampled(), blender::compositor::PosterizeOperation::execute_pixel_sampled(), explodeMesh(), fade_stroke_points(), find_nearest_seq(), flushTransSeq(), followpath_get_tarmat(), frame_from_event(), get_bin_float(), get_ccgdm_data(), gizmo_ruler_invoke(), gizmo_value_from_offset(), gpencil_add_arc_points(), gpencil_apply_randomness(), gpencil_brush_angle(), gpencil_brush_angle_segment(), gpencil_brush_randomize_apply(), gpencil_draw_basic_stroke(), gpencil_find_end_of_stroke_idx(), gpencil_interpolate_modal(), gpencil_interpolate_update_points(), gpencil_mouse_update_shift(), gpencil_primitive_modal(), gpencil_primitive_set_cp(), gpencil_primitive_strength(), gpencil_primitive_update_strokes(), gpencil_set_point_varying_color(), gpencil_stroke_addpoint(), gpencil_stroke_doeraser(), gpencil_stroke_eraser_calc_influence(), gpencil_stroke_newfrombuffer(), gpencil_stroke_normalize_exec(), gpencil_stroke_subdivide(), gpencil_stroke_to_bezier_add_point(), gpencil_stroke_to_path_add_point(), gpencil_subdivide_stroke(), gpencil_vertex_group_smooth_exec(), gpencil_vertexpaint_brush_apply_event(), gpencil_weightpaint_brush_apply_event(), gradientVert_update(), graphview_cursor_apply(), grid_cell_points_cb_ex(), headerTimeSlide(), hex_to_rgb(), hsl_to_rgb(), hsv_clamp_v(), hsv_to_rgb(), hue_correct_apply_threaded(), image_sample_apply(), IMB_getmipmap(), IMB_rectfill_area_replace(), imm_draw_disk_partial(), imm_draw_disk_partial_3d(), ColorBlock::init(), blender::compositor::GaussianBokehBlurOperation::init_data(), init_heights_data(), blender::compositor::VariableSizeBokehBlurOperation::initialize_tile_data(), interp_weights_poly_v2(), interp_weights_poly_v3(), interpolate_particle_value(), isect_seg_seg_v3(), isect_sweeping_sphere_tri_v3(), layer_bucket_init(), line_clip_rect2f(), lineart_get_edge_bounding_areas(), load_tex_task_cb_ex(), blender::draw::loop_edge_factor_get(), make_sep_waveform_view_from_ibuf_float(), make_waveform_view_from_ibuf_float(), mask_expand_floodfill_cb(), mask_expand_normal_floodfill_cb(), mathutils_rna_vector_set(), Matrix_ass_slice(), Matrix_slice(), MatrixAccess_slice(), meshdeform_dynamic_bind(), meshdeform_interp_w(), MOD_solidify_extrude_modifyMesh(), modifyMesh(), motion_path_get_frame_range_to_draw(), multipaint_apply_change(), nla_draw_strip_curves(), blender::ed::space_node::node_resize_modal(), ob_parcurve(), object_blend_read_data(), op_clamp(), op_clamp3(), op_smoothstep(), blender::draw::overhang_remap(), paint_sample_color(), parse_int_clamp(), parse_int_range_relative_clamp(), parse_int_relative_clamp(), particle_settings_blend_read_data(), blender::compositor::DisplaceOperation::pixel_transform(), playanim_toscreen(), pose_slide_modal(), proj_paint_state_screen_coords_init(), project_paint_begin(), project_paint_bucket_bounds(), project_paint_uvpixel_mask(), prop_subscript_ass_array_slice__float_recursive(), prop_subscript_ass_array_slice__int_recursive(), psys_changed_type(), psys_get_particle_on_path(), psys_get_particle_state(), psys_thread_create_path(), py_bl_math_clamp(), py_bl_math_smoothstep(), py_to_float(), py_to_int(), Quaternion_ass_slice(), Quaternion_slice(), radial_control_modal(), RE_engine_begin_result(), RE_engine_frame_set(), RE_engine_update_progress(), region_scale_invoke(), region_scale_modal(), render_border_exec(), safe_acosf(), safe_asinf(), blender::ed::space_node::sample_apply(), screen_geom_find_area_split_point(), screen_geom_vertices_scale_pass(), SCULPT_smooth(), seq_effect_speed_rebuild_map(), seq_snap_target_points_build(), seq_speed_effect_target_frame_get(), set_fcurve_vertex_color(), blender::draw::sharp_remap(), blender::ed::space_node::snode_bg_viewmove_modal(), splineik_evaluate_bone(), stencil_control_calculate(), surface_determineForceTargetPoints(), surfaceGenerateGrid(), system_step(), tablet_tool_handle_tilt(), target_project_edge(), textview_draw_string(), blender::draw::thickness_remap(), transdata_elem_bend(), transdata_elem_bevel_weight(), transdata_elem_crease(), transform_evaluate(), txt_sel_set(), ui_but_calc_float_precision(), ui_but_range_set_soft(), ui_but_string_get_ex(), UI_calc_float_precision(), ui_do_but_SLI(), ui_draw_but_HSV_v(), ui_draw_but_HSVCIRCLE(), ui_draw_but_HSVCUBE(), UI_GetColorPtrBlendShade3ubv(), UI_GetColorPtrShade3ubv(), UI_GetThemeColorBlend3f(), UI_GetThemeColorBlend3ubv(), UI_GetThemeColorBlend4f(), UI_GetThemeColorBlendShade3fv(), UI_GetThemeColorBlendShade3ubv(), UI_GetThemeColorBlendShade4fv(), UI_GetThemeColorShade3fv(), UI_GetThemeColorShade3ubv(), UI_GetThemeColorShade4fv(), UI_GetThemeColorShade4ubv(), UI_GetThemeColorShadeAlpha4fv(), UI_GetThemeColorShadeAlpha4ubv(), ui_handle_list_event(), ui_multibut_states_apply(), ui_numedit_but_COLORBAND(), ui_numedit_but_HISTOGRAM(), ui_numedit_but_HSVCUBE(), ui_numedit_but_NUM(), ui_numedit_but_SLI(), ui_numedit_but_WAVEFORM(), ui_selectcontext_apply(), ui_view2d_curRect_validate_resize(), UI_view2d_scrollers_calc(), uilist_prepare(), uiStyleInit(), unit_as_string(), blender::compositor::DisplaceSimpleOperation::update_memory_buffer_partial(), blender::compositor::HueSaturationValueCorrectOperation::update_memory_buffer_partial(), blender::compositor::MapRangeOperation::update_memory_buffer_partial(), blender::compositor::NormalizeOperation::update_memory_buffer_partial(), blender::compositor::PosterizeOperation::update_memory_buffer_partial(), blender::compositor::VariableSizeBokehBlurOperation::update_memory_buffer_partial(), valuefn(), Vector_ass_slice(), Vector_slice(), vfont_to_curve(), vgroup_invert_subset(), vgroup_levels_subset(), vgroup_normalize(), vgroup_quantize_subset(), vgroup_smooth_subset(), vgroups_datatransfer_interp(), view3d_center_camera_exec(), view3d_set_1_to_1_viewborder(), view3d_zoom_border_exec(), view_ghost_border_exec(), view_zoom_to_window_xy_camera(), viewzoom_apply_3d(), waveModifier_do(), weight_sample_invoke(), weightvg_update_vg(), wm_main_playanim_intern(), wm_pressure_curve(), WM_window_set_dpi(), WM_xr_session_state_nav_scale_set(), wpaint_blend(), and wpaint_get_active_weight().

◆ Clamp

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp

◆ color

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a color

Definition at line 44 of file NOD_static_types.h.

Referenced by acf_generic_channel_backdrop(), acf_generic_dataexpand_backdrop(), acf_generic_root_backdrop(), acf_group_backdrop(), acf_nla_controls_backdrop(), acf_nlaaction_backdrop(), acf_nlaaction_color(), acf_summary_backdrop(), add_ibuf_size(), add_node(), blender::compositor::MemoryBuffer::add_pixel(), MicrofacetFresnelClosure::alloc(), MicrofacetMultiClosure::alloc(), MicrofacetMultiFresnelClosure::alloc(), ANIM_channel_draw(), ANIM_draw_action_framerange(), annotation_draw_onionskins(), annotation_draw_stabilizer(), annotation_draw_strokes(), arrow_draw_geom(), arrow_draw_intern(), bake_targets_output_vertex_colors(), bc_get_cot(), BKE_brush_color_set(), BKE_gpencil_convert_mesh(), BKE_gpencil_from_image(), BKE_gpencil_stroke_set_random_color(), BKE_image_add_generated(), BKE_image_buf_fill_color(), BKE_image_fill_tile(), BKE_palette_color_add(), BKE_palette_color_remove(), blf_texture_draw(), BLI_voronoi_triangulate(), blender::compositor::blur_pixel(), bone_hint_color_shade(), bone_locked_color_shade(), bsdf_principled_hair_sigma_from_reflectance(), btAdjustInternalEdgeContacts(), button2d_draw_intern(), button2d_geom_draw_backdrop(), cage2d_draw_box_corners(), cage2d_draw_box_interaction(), cage2d_draw_circle_handles(), cage2d_draw_circle_wire(), cage3d_draw_box_corners(), cage3d_draw_box_interaction(), cage3d_draw_circle_handles(), cage3d_draw_circle_wire(), btMinkowskiPenetrationDepthSolver::calcPenDepth(), blender::nodes::SeparateRGBAFunction::call(), blender::nodes::node_shader_color_ramp_cc::ColorBandFunction::call(), blender::nodes::node_shader_sepcomb_rgb_cc::SeparateRGBFunction::call(), camera_view3d_reconstruction(), blender::compositor::MathBaseOperation::clamp_if_needed(), blender::compositor::MixBaseOperation::clamp_if_needed(), clip_draw_dopesheet_channels(), clip_draw_dopesheet_main(), closure_bsdf_microfacet_ggx_aniso_fresnel_params(), closure_bsdf_microfacet_ggx_fresnel_params(), closure_bsdf_microfacet_multi_ggx_aniso_fresnel_params(), closure_bsdf_microfacet_multi_ggx_aniso_params(), closure_bsdf_microfacet_multi_ggx_fresnel_params(), closure_bsdf_microfacet_multi_ggx_glass_fresnel_params(), closure_bsdf_microfacet_multi_ggx_glass_params(), closure_bsdf_microfacet_multi_ggx_params(), color_highlight_compress(), color_highlight_uncompress(), Color_idiv(), Color_imul(), color_mul_float(), color_scene_linear_to_srgb(), color_srgb_to_scene_linear(), colorramp_to_array(), VolumeNode::compile(), BsdfNode::compile(), Freestyle::Strip::computeTexCoordWithTips(), RGBToBWNode::constant_fold(), EmissionNode::constant_fold(), BackgroundNode::constant_fold(), InvertNode::constant_fold(), GammaNode::constant_fold(), BrightContrastNode::constant_fold(), SeparateColorNode::constant_fold(), SeparateRGBNode::constant_fold(), SeparateHSVNode::constant_fold(), RGBRampNode::constant_fold(), contract_shape(), convert_float_color_to_byte_color(), blender::io::obj::create_placeholder_image(), cursor_box_draw(), curve_draw_stroke_3d(), customdata_compare(), btCollisionWorld::debugDrawObject(), debugDrawSingleBatch(), btCollisionWorld::debugDrawWorld(), btMultiBodyDynamicsWorld::debugDrawWorld(), default_paint_slot_color_get(), blender::deg::deg_debug_graphviz_legend_color(), blender::deg::deg_debug_graphviz_node_color(), blender::deg::deg_debug_graphviz_relation_color(), ObjectManager::device_update_object_transform(), dial_3d_draw_util(), dial_draw_intern(), dial_geom_draw(), dial_ghostarc_draw(), dial_ghostarc_draw_helpline(), dilate_shape(), do_fill_tile(), do_solid_color(), btSoftBodyHelpers::Draw(), draw_anti_tria(), draw_anti_tria_rect(), blender::ed::space_node::draw_background_color(), draw_bone_degrees_of_freedom(), draw_bone_name(), blender::ed::spreadsheet::SpreadsheetLayoutDrawer::draw_byte_color(), draw_channel_strips(), draw_circle_in_quad(), draw_dividers(), draw_fcurve_handles(), draw_keyframe_shape(), draw_line_bounds(), draw_line_loop(), draw_line_pairs(), draw_marker_line(), draw_marker_texts(), draw_nla_main_data(), draw_overshoot_triangle(), draw_parallel_lines(), draw_plane_marker_ex(), draw_primitive_view(), draw_primitive_view_impl(), draw_scope_end(), draw_tile_background(), btIDebugDraw::drawAabb(), btIDebugDraw::drawArc(), drawAutoKeyWarning(), drawBox(), btIDebugDraw::drawBox(), btIDebugDraw::drawCapsule(), btIDebugDraw::drawCone(), btIDebugDraw::drawCylinder(), btIDebugDraw::drawPlane(), btIDebugDraw::drawSphere(), btIDebugDraw::drawSpherePatch(), btIDebugDraw::drawTriangle(), drop_color_invoke(), DRW_cache_cursor_get(), DRW_debug_bbox(), DRW_debug_line_v3v3(), DRW_debug_m4_as_bbox(), DRW_debug_polygon_v3(), DRW_debug_sphere(), DRW_globals_update(), drw_shgroup_bone_axes(), drw_shgroup_bone_custom_empty(), drw_shgroup_bone_custom_mesh_wire(), drw_shgroup_bone_custom_wire(), drw_shgroup_bone_relationship_lines_ex(), drw_shgroup_bone_wire(), dynamic_paint_apply_surface_vpaint_blend_cb(), dynamic_paint_set_init_color_tex_to_imseq_cb(), dynamic_paint_set_init_color_vcol_to_imseq_cb(), dynamicPaint_setInitialColor(), ED_gizmo_draw_preset_facemap(), ed_gizmo_draw_preset_geometry(), ED_gpencil_trace_image_to_bitmap(), ED_imapaint_bucket_fill(), ED_imbuf_sample_draw(), ED_node_socket_draw(), ED_region_do_draw(), ED_region_grid_draw(), ED_space_image_get_display_channel_mask(), edit_text_cache_populate_boxes(), EEVEE_bloom_init(), EEVEE_material_default_error_get(), blender::compositor::SMAAEdgeDetectionOperation::execute_pixel(), blender::compositor::SMAANeighborhoodBlendingOperation::execute_pixel(), blender::compositor::ConvertColorProfileOperation::execute_pixel_sampled(), blender::compositor::ConvertColorToVectorOperation::execute_pixel_sampled(), blender::compositor::ConvertRGBToYCCOperation::execute_pixel_sampled(), blender::compositor::PlaneDistortWarpImageOperation::execute_pixel_sampled(), blender::compositor::TextureAlphaOperation::execute_pixel_sampled(), blender::compositor::CompositorOperation::execute_region(), blender::compositor::PreviewOperation::execute_region(), blender::draw::extract_sculpt_data_init_subdiv(), film_get_pass_pixel_combined(), film_get_pass_pixel_float4(), blender::nodes::node_fn_input_color_cc::fn_node_input_color_build_multi_function(), blender::ed::space_node::frame_node_draw(), blender::ed::space_node::frame_node_draw_label(), fresnel_conductor(), FrsMaterial_ambient_set(), FrsMaterial_diffuse_set(), FrsMaterial_emission_set(), FrsMaterial_line_set(), FrsMaterial_mathutils_get_index(), FrsMaterial_mathutils_set_index(), FrsMaterial_specular_set(), Freestyle::BlenderStrokeRenderer::GenerateStrokeMesh(), blender::ed::geometry::geometry_color_attribute_add_exec(), blender::nodes::get_multi_function(), get_rgba_fixed_color(), EffectsExporter::getcol(), Freestyle::BlenderStrokeRenderer::GetStrokeShader(), gizmo2d_resize_setup(), gizmo2d_rotate_setup(), gizmo2d_xform_setup(), gizmo_cage2d_draw_intern(), gizmo_cage3d_draw_intern(), gizmo_mesh_spin_init_setup(), gl_shaded_color(), gl_shaded_color_get(), gl_shaded_color_get_fl(), gpencil_add_material(), gpencil_brush_cursor_draw(), gpencil_draw_basic_stroke(), gpencil_draw_stroke_3d(), gpencil_draw_stroke_volumetric_3d(), gpencil_invert_image(), gpencil_light_ambient_add(), gpencil_material_hide_exec(), gpencil_primitive_arc(), gpencil_primitive_bezier(), gpencil_primitive_circle(), gpencil_primitive_line(), gpencil_primitive_rectangle(), gpencil_primitive_set_cp(), gpencil_shade_color(), gpencil_vertexpaint_set_exec(), gpu_batch_preset_rectf_tris_color_ex(), GPU_viewport_bind_from_offscreen(), gpu_viewport_draw_colormanaged(), GPU_viewport_draw_to_screen_ex(), blender::compositor::DebugInfo::graphviz_legend_color(), blender::compositor::DebugInfo::graphviz_legend_group(), blender::compositor::DebugInfo::graphviz_system(), hash_float_to_color(), hash_vector2_to_color(), hash_vector3_to_color(), hash_vector4_to_color(), histogram_draw_one(), hsl_to_rgb(), hsv_to_rgb(), icon_draw_rect_input(), icon_draw_rect_input_symbol(), icon_draw_rect_input_text(), icon_draw_size(), image_buf_fill_color_slice(), image_new_exec(), IMB_colormanagement_imbuf_for_write(), imb_load_openexr(), IMB_sampleImageAtLocation(), immDrawPixelsTexScaledFullSize(), immDrawPixelsTexTiled(), immDrawPixelsTexTiled_clipping(), immDrawPixelsTexTiled_scaling(), immDrawPixelsTexTiled_scaling_clipping(), immRectf_fast_with_color(), immRecti_fast_with_color(), immUniformThemeColor(), immUniformThemeColor3(), immUniformThemeColorAlpha(), immUniformThemeColorBlend(), immUniformThemeColorBlendShade(), immUniformThemeColorShade(), immUniformThemeColorShadeAlpha(), invert(), kernel_background_evaluate(), layerDefault_propcol(), light_emission_node_to_energy(), light_emission_unify(), manta_noise_get_rgba_fixed_color(), manta_smoke_get_rgba_fixed_color(), blender::eevee::MaterialModule::MaterialModule(), metaball_instance_data_set(), mf_eval(), mf_sample(), blender::attribute_math::ColorGeometry4bMixer::mix_in(), blender::attribute_math::ColorGeometry4fMixer::mix_in(), motion_path_cache(), move3d_draw_intern(), move_geom_draw(), nla_action_draw_keyframes(), nla_action_get_color(), nla_draw_strip(), nla_draw_use_dashed_outlines(), nla_strip_get_color_inside(), NODE_DEFINE(), blender::ed::space_node::node_draw_basis(), blender::ed::space_node::node_draw_extra_info_panel(), blender::ed::space_node::node_draw_hidden(), blender::ed::space_node::node_draw_sockets(), blender::nodes::node_shader_volume_principled_cc::node_shader_gpu_volume_principled(), blender::ed::space_node::node_socket_draw(), blender::ed::space_node::node_socket_draw_multi_input(), blender::ed::space_node::node_socket_draw_nested(), noise_texture_1d(), noise_texture_2d(), noise_texture_3d(), noise_texture_4d(), outliner_draw_iconrow_number(), OVERLAY_armature_cache_populate(), OVERLAY_bounds(), OVERLAY_collision(), OVERLAY_edit_gpencil_cache_init(), OVERLAY_edit_metaball_cache_populate(), OVERLAY_edit_uv_cache_init(), OVERLAY_empty_cache_populate(), OVERLAY_empty_shape(), OVERLAY_extra_cache_populate(), OVERLAY_extra_line_dashed(), OVERLAY_extra_loose_points(), OVERLAY_extra_point(), OVERLAY_extra_wire(), OVERLAY_fade_cache_init(), OVERLAY_forcefield(), overlay_gpencil_draw_stroke_color_name(), OVERLAY_image_empty_cache_populate(), OVERLAY_lattice_cache_populate(), OVERLAY_light_cache_populate(), OVERLAY_metaball_cache_populate(), OVERLAY_mode_transfer_cache_populate(), OVERLAY_object_name(), OVERLAY_particle_cache_populate(), OVERLAY_texture_space(), OVERLAY_volume_extra(), OVERLAY_wireframe_cache_populate(), blender::ed::sculpt_paint::paint::image::PaintingKernel< ImageBuffer >::paint(), paint_2d_bucket_fill(), paint_2d_fill_add_pixel_byte(), paint_2d_fill_add_pixel_float(), paint_brush_color_get(), blender::ed::sculpt_paint::image::ops::paint::ImagePaintMode::paint_bucket_fill(), paint_sample_color(), palette_blend_write(), palette_color_add_exec(), palette_color_delete_exec(), palette_extract_img_exec(), palette_join_exec(), palette_sort_exec(), panel_draw_highlight_border(), particle_batch_cache_ensure_edit_inner_pos(), particle_batch_cache_ensure_edit_tip_pos(), blender::bke::pbvh_vertex_color_set(), plane_track_colors(), premul_float_to_straight_uchar(), premul_to_straight_v4(), premul_ushort_to_straight_uchar(), btSoftBodyTriangleCallback::processTriangle(), proj_paint_color_attribute_create(), proj_paint_image_create(), blender::gpu::MTLFrameBuffer::read(), blender::io::alembic::read_custom_data_mcols(), blender::io::usd::USDLightReader::read_object_data(), region_draw_azone_tab_arrow(), region_draw_emboss(), region_draw_status_text(), Freestyle::PSStrokeRenderer::RenderStrokeRepBasic(), rgb_ramp_lookup(), rgb_to_hsl(), rgb_to_hsv(), rna_def_modifier_type_common(), blender::compositor::sample(), blender::compositor::sample_bilinear_horizontal(), blender::compositor::sample_bilinear_vertical(), blender::compositor::sample_image_at_location(), sculpt_mask_by_color_contiguous(), SCULPT_vertex_color_set(), blender::compositor::InvertOperation::set_color(), set_draw_marker_area_color(), set_fcurve_vertex_color(), set_roundbox_vertex(), set_viewport_material_props(), shadecolors4(), straight_to_premul_v4(), straight_uchar_to_premul_float(), straight_uchar_to_premul_ushort(), studiolight_calculate_radiance(), studiolight_evaluate_specular_radiance_buffer(), studiolight_irradiance_preview(), studiolight_lights_eval(), studiolight_matcap_preview(), studiolight_radiance_preview(), studiolight_spherical_harmonics_calculate_coefficients(), studiolight_spherical_harmonics_eval(), svm_brightness_contrast(), svm_combine_color(), svm_math_gamma_color(), svm_node_brightness(), svm_node_closure_bsdf(), svm_node_combine_color(), svm_node_combine_hsv(), svm_node_curves(), svm_node_gamma(), svm_node_hsv(), svm_node_invert(), svm_node_normal_map(), svm_node_principled_volume(), svm_node_rgb_ramp(), svm_node_separate_color(), svm_node_separate_hsv(), svm_node_tex_magic(), svm_node_tex_noise(), svm_node_tex_white_noise(), svm_node_wavelength(), svm_separate_color(), HdCyclesLight::Sync(), texture_paint_add_texture_paint_slot_invoke(), timeline_cache_color_get(), timeline_cache_draw_single(), timeline_cache_modify_color_based_on_state(), track_channel_color(), tselem_draw_icon(), ui_do_but_COLOR(), UI_draw_box_shadow(), ui_draw_but_HISTOGRAM(), ui_draw_but_HSVCIRCLE(), ui_draw_clip_tri(), ui_draw_dropshadow(), UI_draw_icon_tri(), UI_draw_roundbox_aa(), UI_draw_text_underline(), ui_draw_widget_back_color(), ui_draw_widget_menu_back_color(), UI_FontThemeColor(), UI_icon_get_theme_color(), ui_palette_set_active(), ui_shadowbox(), UI_view2d_dot_grid_draw(), UI_view2d_multi_grid_draw(), uiDefButImage(), uiTemplateColorPicker(), uiTemplateNodeSocket(), uiTemplatePalette(), blender::compositor::BokehBlurOperation::update_memory_buffer_partial(), blender::compositor::BrightnessOperation::update_memory_buffer_partial(), blender::compositor::ChangeHSVOperation::update_memory_buffer_partial(), blender::compositor::ChannelMatteOperation::update_memory_buffer_partial(), blender::compositor::ColorSpillOperation::update_memory_buffer_partial(), blender::compositor::ConvolutionEdgeFilterOperation::update_memory_buffer_partial(), blender::compositor::DirectionalBlurOperation::update_memory_buffer_partial(), blender::compositor::GammaCorrectOperation::update_memory_buffer_partial(), blender::compositor::GammaUncorrectOperation::update_memory_buffer_partial(), blender::compositor::GaussianBokehBlurOperation::update_memory_buffer_partial(), blender::compositor::GaussianBlurReferenceOperation::update_memory_buffer_partial(), blender::compositor::GlareThresholdOperation::update_memory_buffer_partial(), blender::compositor::InvertOperation::update_memory_buffer_partial(), blender::compositor::LuminanceMatteOperation::update_memory_buffer_partial(), blender::compositor::PlaneDistortWarpImageOperation::update_memory_buffer_partial(), blender::compositor::PreviewOperation::update_memory_buffer_partial(), blender::compositor::ProjectorLensDistortionOperation::update_memory_buffer_partial(), blender::compositor::SetAlphaMultiplyOperation::update_memory_buffer_partial(), blender::compositor::SetAlphaReplaceOperation::update_memory_buffer_partial(), blender::compositor::SMAAEdgeDetectionOperation::update_memory_buffer_partial(), blender::compositor::SMAANeighborhoodBlendingOperation::update_memory_buffer_partial(), blender::compositor::VariableSizeBokehBlurOperation::update_memory_buffer_partial(), blender::compositor::ZCombineOperation::update_memory_buffer_partial(), v3d_cursor_plane_draw(), v3d_cursor_plane_draw_grid(), vertex_color_brightness_contrast_exec(), vertex_color_hsv_exec(), vertex_color_invert_exec(), vertex_color_levels_exec(), vertex_color_set(), view2d_draw_lines_internal(), voronoi_addTriangulationPoint(), vpaint_get_current_col(), walkStacklessQuantizedTree(), walkStacklessQuantizedTreeAgainstRay(), widget_draw_icon(), WIDGETGROUP_gizmo_draw_prepare(), wm_block_create_about(), wm_gizmo_geometryinfo_draw(), WM_gizmo_get_color(), WM_gizmo_set_color(), wm_gizmo_vec_draw(), wm_xr_controller_aim_draw(), wm_xr_controller_model_draw(), workbench_volume_material_color(), workbench_volume_object_cache_populate(), blender::compositor::write_buffer_rect(), blender::compositor::MemoryBuffer::write_pixel(), write_severity(), xyY_to_xyz(), and xyz_to_rgb().

◆ Color

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed Float Map an input float to a curve and outputs a float value Separate Color

Definition at line 124 of file NOD_static_types.h.

Referenced by bc_get_ambient(), bc_get_base_color(), bc_get_cot(), bc_get_emission(), bc_get_reflective(), bc_get_specular(), blender::color::BLI_mix_colors(), calculate_average_color(), do_vpaint_brush_blur_loops(), do_vpaint_brush_blur_verts(), do_vpaint_brush_smear(), blender::compositor::FastGaussianBlurOperation::FastGaussianBlurOperation(), fromFloat(), blender::compositor::GaussianBlurBaseOperation::GaussianBlurBaseOperation(), blender::compositor::GaussianBlurReferenceOperation::GaussianBlurReferenceOperation(), blender::compositor::GaussianBokehBlurOperation::GaussianBokehBlurOperation(), EffectsExporter::getcol(), gpencil_modifier_type_init(), blender::color::mix_add(), blender::color::mix_alpha_add(), blender::color::mix_alpha_sub(), blender::color::mix_blend(), blender::color::mix_color(), blender::color::mix_colorburn(), blender::color::mix_colordodge(), blender::color::mix_darken(), blender::color::mix_difference(), blender::color::mix_exclusion(), blender::color::mix_hardlight(), blender::color::mix_hue(), blender::color::mix_lighten(), blender::color::mix_linearburn(), blender::color::mix_linearlight(), blender::color::mix_luminosity(), blender::color::mix_mul(), blender::color::mix_overlay(), blender::color::mix_pinlight(), blender::color::mix_saturation(), blender::color::mix_screen(), blender::color::mix_softlight(), blender::color::mix_sub(), blender::color::mix_vividlight(), LightsExporter::operator()(), blender::compositor::ScaleOperation::ScaleOperation(), MaterialNode::set_alpha(), MaterialNode::set_ambient(), MaterialNode::set_diffuse(), MaterialNode::set_emission(), MaterialNode::set_opacity(), MaterialNode::set_reflective(), MaterialNode::set_specular(), AnimationImporter::translate_Animations(), blender::compositor::TranslateCanvasOperation::TranslateCanvasOperation(), blender::compositor::TranslateOperation::TranslateOperation(), vertex_color_set(), vpaint_blend(), vpaint_do_draw(), vpaint_do_paint(), vpaint_get_current_col(), and DocumentImporter::writeLight().

◆ COMBHSV

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space COMBHSV

Definition at line 110 of file NOD_static_types.h.

◆ CombineHSV

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space CombineHSV

Definition at line 110 of file NOD_static_types.h.

◆ CombineRGB

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative CombineRGB

Definition at line 46 of file NOD_static_types.h.

◆ COMBRGB

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative COMBRGB

Definition at line 46 of file NOD_static_types.h.

◆ Contrast

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Contrast

Definition at line 34 of file NOD_static_types.h.

◆ Coordinate

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Coordinate

Definition at line 106 of file NOD_static_types.h.

◆ Curve

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed Float Curve

Definition at line 122 of file NOD_static_types.h.

◆ CURVE_FLOAT

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed CURVE_FLOAT

Definition at line 122 of file NOD_static_types.h.

◆ CURVE_VEC

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color CURVE_VEC

Definition at line 36 of file NOD_static_types.h.

◆ curves

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to curves

Definition at line 36 of file NOD_static_types.h.

Referenced by blender::nodes::node_geo_curve_spline_parameter_cc::accumulated_lengths_curve_domain(), acf_dscurves_setting_ptr(), action_get_item_transforms(), action_to_animato(), blender::bke::adapt_curve_domain_curve_to_point_impl(), blender::bke::adapt_curve_domain_point_to_curve_impl(), blender::geometry::add_curves_on_mesh(), add_node(), animdata_filter_ds_obdata(), blender::ed::curves::any_point_selected(), AnimationImporter::apply_matrix_curves(), apply_objects_internal(), AnimationImporter::Assign_transform_animations(), CurveComponent::attributes_for_write(), bc_has_animations(), BKE_curves_add(), BKE_curves_batch_cache_dirty_tag(), BKE_curves_batch_cache_free(), BKE_curves_boundbox_get(), BKE_curves_data_update(), BKE_id_attribute_copy_domains_temp(), BKE_object_material_array_p(), BKE_object_material_len_p(), blender::deg::DepsgraphRelationBuilder::build_animdata_curves_targets(), blender::bke::build_point_to_curve_map(), blender::bke::calculate_evaluated_offsets(), blender::nodes::node_geo_curve_sample_cc::SampleCurveFunction::call(), CurvesNode::compile(), GeometrySet::compute_boundbox_without_instances(), CurvesNode::constant_fold(), blender::bke::construct_curve_length_gvarray(), blender::nodes::node_geo_curve_spline_parameter_cc::construct_curve_length_parameter_varray(), blender::nodes::node_geo_curve_spline_parameter_cc::construct_curve_parameter_varray(), blender::nodes::node_geo_input_spline_length_cc::construct_curve_point_count_gvarray(), blender::nodes::node_geo_input_tangent_cc::construct_curve_tangent_gvarray(), blender::nodes::node_geo_curve_spline_parameter_cc::construct_index_on_spline_varray(), blender::bke::copy_with_removed_curves(), blender::bke::copy_with_removed_points(), blender::nodes::node_geo_curve_primitive_arc_cc::create_arc_curve_from_points(), blender::nodes::node_geo_curve_primitive_arc_cc::create_arc_curve_from_radius(), blender::bke::create_attribute_providers_for_curve(), blender::bke::tests::create_basic_curves(), blender::nodes::node_geo_curve_primitive_bezier_segment_cc::create_bezier_segment_curve(), blender::geometry::create_curve_from_vert_indices(), blender::nodes::node_geo_string_to_curves_cc::create_curve_instances(), blender::nodes::node_geo_curve_primitive_line_cc::create_direction_line_curve(), blender::nodes::node_geo_curve_primitive_circle_cc::create_point_circle_curve(), blender::nodes::node_geo_curve_primitive_line_cc::create_point_line_curve(), blender::nodes::node_geo_curve_primitive_quadratic_bezier_cc::create_quadratic_bezier_curve(), blender::nodes::node_geo_curve_primitive_circle_cc::create_radius_circle_curve(), blender::nodes::node_geo_curve_primitive_spiral_cc::create_spiral_curve(), blender::nodes::node_geo_curve_primitive_star_cc::create_star_curve(), GeometrySet::create_with_curves(), blender::nodes::node_geo_curve_sample_cc::curve_accumulated_lengths(), curve_create_curves_lines(), curve_create_curves_pos(), curve_eval_render_wire_verts_edges_len_get(), curve_eval_to_curves(), blender::nodes::node_geo_curve_fill_cc::curve_fill_calculate(), blender::bke::curve_legacy_to_curves(), blender::nodes::node_geo_curve_spline_parameter_cc::curve_length_point_domain(), blender::bke::curve_normal_point_domain(), blender::bke::curve_normals_varray(), curve_rename_fcurves(), blender::nodes::node_geo_input_tangent_cc::curve_tangent_point_domain(), curves_batch_cache_clear(), curves_batch_cache_ensure_procedural_indices(), curves_batch_cache_ensure_procedural_pos(), curves_batch_cache_ensure_procedural_strand_data(), curves_batch_cache_fill_segments_indices(), curves_batch_cache_fill_segments_proc_pos(), curves_batch_cache_fill_strands_data(), curves_batch_cache_get(), curves_batch_cache_init(), curves_batch_cache_valid(), curves_batch_ensure_attribute(), curves_blend_read_data(), curves_blend_read_expand(), curves_blend_read_lib(), curves_blend_write(), blender::bke::curves_bounds(), curves_ensure_attributes(), curves_ensure_procedural_data(), curves_foreach_id(), curves_free_data(), curves_init_data(), blender::bke::curves_new_nomain(), blender::bke::curves_new_nomain_single(), blender::ed::curves::curves_poll_impl(), blender::ed::curves::set_selection_domain::curves_set_selection_domain_exec(), curves_to_curve_eval(), blender::nodes::node_geo_deform_curves_on_surface_cc::deform_curves(), blender::nodes::node_geo_delete_geometry_cc::delete_curves_selection(), GeometryManager::device_update_mesh(), Freestyle::Controller::displayDensityCurves(), blender::nodes::node_geo_curve_fill_cc::do_cdt(), do_version_bbone_scale_fcurve_fix(), blender::io::usd::USDHairWriter::do_write(), blender::bke::domain_custom_data(), blender::bke::domain_num(), drivers_path_rename_fix(), DRW_curves_batch_cache_create_requested(), DRW_curves_batch_cache_dirty_tag(), DRW_curves_batch_cache_free(), DRW_curves_batch_cache_free_old(), DRW_curves_batch_cache_get_edit_points(), DRW_curves_batch_cache_validate(), drw_curves_cache_get(), DRW_curves_material_count_get(), DRW_curves_pos_buffer_get(), DRW_curves_texture_for_evaluated_attribute(), DRW_shgroup_curves_create_sub(), blender::nodes::node_geo_duplicate_elements_cc::duplicate_curves(), ensure_seg_pt_count(), AnimationImporter::evaluate_animation(), blender::bke::evaluated_attribute_if_necessary(), everything_selected(), blender::ed::sculpt_paint::ShrinkCurvesEffect::execute(), blender::ed::sculpt_paint::ScaleCurvesEffect::execute(), blender::geometry::execute_realize_curve_task(), AnimationExporter::export_curve_animation_set(), fcurve_path_rename(), fcurves_path_remove_fix(), fcurves_path_rename_fix(), fcurves_to_pchan_links_get(), blender::bke::curves::fill_points(), blender::ed::sculpt_paint::find_curves_brush_position(), AnimationImporter::find_frames(), AnimationImporter::find_frames_old(), blender::geometry::gather_curves_to_realize(), blender::geometry::gather_realize_tasks_recursive(), blender::nodes::node_geo_curve_to_mesh_cc::geometry_set_curve_to_mesh(), blender::bke::get_attribute_accessor_for_write(), blender::bke::get_curve_single_vert(), blender::bke::get_curves_accessor_functions(), blender::ed::sculpt_paint::get_curves_selection(), get_domains(), AnimationExporter::get_modified_export_curve(), blender::bke::get_mutable_attribute(), blender::nodes::node_geo_string_to_curves_cc::get_pivot_point(), blender::ed::sculpt_paint::get_point_selection(), blender::bke::get_span_attribute(), blender::bke::get_varray_attribute(), blender::nodes::node_geo_curve_spline_parameter_cc::CurveParameterFieldInput::get_varray_for_context(), blender::nodes::node_geo_curve_spline_parameter_cc::CurveLengthParameterFieldInput::get_varray_for_context(), blender::nodes::node_geo_curve_spline_parameter_cc::IndexOnSplineFieldInput::get_varray_for_context(), blender::nodes::node_geo_curve_endpoint_selection_cc::EndpointFieldInput::get_varray_for_context(), blender::ed::curves::has_anything_selected(), blender::geometry::interpolate_position_with_interpolation(), blender::geometry::interpolate_position_without_interpolation(), intersection_curve_shadow_transparency(), intersection_get_shader_flags(), intersection_get_shader_from_isect_prim(), make_new_animlistelem(), mesh_new_from_evaluated_curve_type_object(), modifier_apply_obdata(), AnimationImporter::modify_fcurve(), NODE_DEFINE(), blender::nodes::node_geo_curve_fillet_cc::node_geo_exec(), blender::nodes::node_geo_curve_length_cc::node_geo_exec(), blender::nodes::node_geo_curve_primitive_arc_cc::node_geo_exec(), blender::nodes::node_geo_curve_primitive_bezier_segment_cc::node_geo_exec(), blender::nodes::node_geo_curve_primitive_circle_cc::node_geo_exec(), blender::nodes::node_geo_curve_primitive_line_cc::node_geo_exec(), blender::nodes::node_geo_curve_primitive_quadratic_bezier_cc::node_geo_exec(), blender::nodes::node_geo_curve_primitive_quadrilateral_cc::node_geo_exec(), blender::nodes::node_geo_curve_primitive_spiral_cc::node_geo_exec(), blender::nodes::node_geo_curve_primitive_star_cc::node_geo_exec(), blender::nodes::node_geo_curve_reverse_cc::node_geo_exec(), blender::nodes::node_geo_curve_sample_cc::node_geo_exec(), blender::nodes::node_geo_deform_curves_on_surface_cc::node_geo_exec(), blender::nodes::node_geo_mesh_to_curve_cc::node_geo_exec(), blender::nodes::node_geo_separate_components_cc::node_geo_exec(), blender::nodes::node_geo_set_material_cc::node_geo_exec(), object_origin_set_exec(), outliner_add_id_contents(), overlay_edit_curves_add_ob_to_pass(), OVERLAY_sculpt_curves_cache_populate(), Hair::pack_curves(), parent_set_invoke_menu(), blender::geometry::preprocess_curves(), blender::ed::curves::primitive_random_sphere(), CurveComponent::release(), GeometryComponentEditData::remember_deformed_curve_positions_if_necessary(), CurveComponent::replace(), GeometrySet::replace_curves(), request_attribute(), blender::geometry::retrieve_curve_sizes(), blender::ed::sculpt_paint::retrieve_selected_curves(), blender::ed::sculpt_paint::retrieve_selected_points(), blender::ed::sculpt_paint::sample_curves_3d_brush(), blender::ed::curves::select_all::select_all_exec(), blender::nodes::node_geo_curve_handle_type_selection_cc::select_by_handle_type(), blender::ed::sculpt_paint::select_end::select_end_exec(), blender::ed::sculpt_paint::select_grow::select_grow_invoke_per_curve(), blender::ed::sculpt_paint::select_grow::select_grow_modal(), blender::ed::sculpt_paint::select_grow::select_grow_update(), blender::ed::sculpt_paint::select_random::select_random_exec(), blender::nodes::node_geo_set_curve_handles_cc::set_position_in_component(), blender::nodes::node_geo_curve_set_handle_type_cc::set_type_in_component(), shader_setup_from_curve(), blender::ed::curves::snap_curves_to_surface::snap_curves_to_surface_exec_object(), tag_component_curve_types_changed(), tag_component_normals_changed(), tag_component_positions_changed(), tag_component_topology_changed(), blender::bke::tests::TEST(), blender::nodes::transform_geometry_set(), AnimationImporter::translate_animation_OLD(), blender::nodes::translate_geometry_set(), blender::ed::curves::convert_to_particle_system::try_convert_single_object(), blender::geometry::try_curves_conversion_in_place(), unlink_material_fn(), AnimationImporter::unused_fcurve(), and blender::ed::sculpt_paint::use_add_density_mode().

◆ Curves

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Curves

Definition at line 36 of file NOD_static_types.h.

◆ Data

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Data

Definition at line 38 of file NOD_static_types.h.

◆ def_clamp

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position def_clamp

Definition at line 40 of file NOD_static_types.h.

◆ def_float_curve

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed def_float_curve

Definition at line 122 of file NOD_static_types.h.

◆ def_group

def_group

Definition at line 21 of file NOD_static_types.h.

◆ def_group_output

def_group_output

Definition at line 23 of file NOD_static_types.h.

◆ def_mix_rgb

Group Output data from inside of a node group A color picker def_mix_rgb

Definition at line 28 of file NOD_static_types.h.

◆ def_sh_bevel

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components def_sh_bevel

Definition at line 116 of file NOD_static_types.h.

◆ def_sh_combsep_color

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed Float Map an input float to a curve and outputs a float value def_sh_combsep_color

Definition at line 124 of file NOD_static_types.h.

◆ def_sh_normal_map

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value def_sh_normal_map

Definition at line 91 of file NOD_static_types.h.

◆ def_sh_output

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate def_sh_output

Definition at line 52 of file NOD_static_types.h.

◆ def_sh_script

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces def_sh_script

Definition at line 93 of file NOD_static_types.h.

◆ def_sh_tex_brick

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells def_sh_tex_brick

Definition at line 104 of file NOD_static_types.h.

◆ def_sh_tex_coord

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks def_sh_tex_coord

Definition at line 106 of file NOD_static_types.h.

◆ def_sh_tex_image

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block def_sh_tex_image

Definition at line 94 of file NOD_static_types.h.

◆ def_sh_tex_noise

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture def_sh_tex_noise

Definition at line 98 of file NOD_static_types.h.

◆ def_sh_tex_sky

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture def_sh_tex_sky

Definition at line 96 of file NOD_static_types.h.

◆ def_sh_tex_voronoi

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise def_sh_tex_voronoi

Definition at line 102 of file NOD_static_types.h.

◆ def_sh_tex_wave

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise def_sh_tex_wave

Definition at line 100 of file NOD_static_types.h.

◆ def_sh_tex_white_noise

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction def_sh_tex_white_noise

Definition at line 120 of file NOD_static_types.h.

◆ def_sh_tex_wireframe

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud def_sh_tex_wireframe

Definition at line 87 of file NOD_static_types.h.

◆ def_sh_vect_transform

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes def_sh_vect_transform

Definition at line 108 of file NOD_static_types.h.

◆ def_sh_vector_displacement

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders def_sh_vector_displacement

Definition at line 118 of file NOD_static_types.h.

◆ def_sh_vertex_color

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels def_sh_vertex_color

Definition at line 112 of file NOD_static_types.h.

◆ def_vector_curve

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color def_vector_curve

Definition at line 36 of file NOD_static_types.h.

◆ def_vector_math

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum def_vector_math

Definition at line 42 of file NOD_static_types.h.

◆ Displacement

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displacement

Definition at line 118 of file NOD_static_types.h.

◆ EEVEE_SPECULAR

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model EEVEE_SPECULAR

Definition at line 50 of file NOD_static_types.h.

◆ EeveeSpecular

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model EeveeSpecular

Definition at line 50 of file NOD_static_types.h.

◆ FloatCurve

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed FloatCurve

Definition at line 122 of file NOD_static_types.h.

◆ FRESNEL

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate World Output light color information to the scene s World FRESNEL

Definition at line 54 of file NOD_static_types.h.

◆ Fresnel

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate World Output light color information to the scene s World Fresnel

Definition at line 54 of file NOD_static_types.h.

◆ green

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its green

Definition at line 46 of file NOD_static_types.h.

◆ Group

Group

Definition at line 21 of file NOD_static_types.h.

◆ GROUP

GROUP

Definition at line 21 of file NOD_static_types.h.

◆ GROUP_OUTPUT

GROUP_OUTPUT

Definition at line 23 of file NOD_static_types.h.

◆ GroupOutput

GroupOutput

Definition at line 23 of file NOD_static_types.h.

◆ HSV

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine HSV

Definition at line 110 of file NOD_static_types.h.

◆ hue

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its hue

◆ HUE_SAT

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue HUE_SAT

Definition at line 47 of file NOD_static_types.h.

◆ HueSaturation

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue HueSaturation

Definition at line 47 of file NOD_static_types.h.

◆ Info

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Info

◆ instance

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object instance

Definition at line 83 of file NOD_static_types.h.

Referenced by blender::nodes::node_geo_instance_on_points_cc::add_instances_from_component(), GHOST_XrSession::attachActionSets(), bpy_class_call(), GHOST_XrGraphicsBindingOpenGL::checkVersionRequirements(), GHOST_DirectManipulationHelper::create(), blender::opensubdiv::GLComputeEvaluator::Create(), GHOST_XrActionSet::createAction(), GHOST_XrSession::createActionBindings(), GHOST_XrSession::createActions(), GHOST_XrSession::createActionSet(), GHOST_XrAction::createBinding(), Freestyle::Canvas::Draw(), eevee_cache_finish(), eevee_cache_init(), eevee_cache_populate(), eevee_instance_free(), eevee_render_to_image(), blender::opensubdiv::GLComputeEvaluator::EvalPatches(), blender::opensubdiv::GLComputeEvaluator::EvalPatchesFaceVarying(), blender::opensubdiv::GLComputeEvaluator::EvalPatchesVarying(), blender::opensubdiv::GLComputeEvaluator::EvalStencils(), blender::bke::pbvh::pixels::NodeData::free_func(), DebugFlags::get(), GHOST_XrAction::GHOST_XrAction(), GHOST_XrActionProfile::GHOST_XrActionProfile(), GHOST_XrActionSet::GHOST_XrActionSet(), GHOST_XrControllerModel::GHOST_XrControllerModel(), GHOST_XrEventPollNext(), init_controller_model_extension_functions(), GHOST_XrSession::loadControllerModel(), blender::nodes::node_geo_instance_on_points_cc::node_geo_exec(), Freestyle::Functions1D::TimeStampF1D::operator()(), Freestyle::Functions1D::ChainingTimeStampF1D::operator()(), OVERLAY_instance_free(), pyrna_struct_as_instance(), pyrna_struct_CreatePyObject(), RNA_def_struct_register_funcs(), and HdCyclesGeometry< Base, CyclesBase >::Sync().

◆ INVERT

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation INVERT

Definition at line 44 of file NOD_static_types.h.

◆ Invert

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert

Definition at line 44 of file NOD_static_types.h.

◆ Map

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Map

Definition at line 91 of file NOD_static_types.h.

◆ Math

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Math

Definition at line 42 of file NOD_static_types.h.

◆ metallic

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of metallic

◆ MIX_RGB

Group Output data from inside of a node group A color picker MIX_RGB

Definition at line 28 of file NOD_static_types.h.

◆ MixRGB

Group Output data from inside of a node group A color picker MixRGB

Definition at line 28 of file NOD_static_types.h.

◆ nNote

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners nNote

Definition at line 87 of file NOD_static_types.h.

◆ NODE_GROUP

NODE_GROUP

Definition at line 21 of file NOD_static_types.h.

Referenced by blender::compositor::NodeGraph::add_bNode(), animdata_filter_ds_nodetree(), blo_do_versions_250(), blender::deg::DepsgraphNodeBuilder::build_nodetree(), blender::deg::DepsgraphRelationBuilder::build_nodetree(), buttons_texture_modifier_geonodes_users_add(), buttons_texture_users_find_nodetree(), check_tree_for_time_node(), blender::compositor::COM_convert_bnode(), blender::ed::space_node::compo_tag_output_nodes(), do_versions_after_linking_250(), ED_node_set_active(), free_localized_node_groups(), blender::ed::space_node::get_exec_time_other_nodes(), blender::ed::curves::has_surface_deformation_node(), blender::nodes::NodeRef::is_group_node(), blender::ed::space_node::node_add_group_exec(), blender::ed::space_node::node_common_set_butfunc(), blender::ed::space_node::node_draw_basis(), blender::ed::space_node::node_get_accessed_attributes_row(), node_get_active(), node_get_static_idname(), blender::ed::space_node::node_link_item_apply(), blender::ed::space_node::node_link_item_compare(), node_preview_init_tree_recursive(), node_preview_tag_used_recursive(), blender::ed::space_node::node_shader_script_update_text_recursive(), node_tree_has_compositor_output(), nodeTypeUndefined(), ntree_foreach_texnode_recursive(), ntree_shader_groups_expand_inputs(), ntree_shader_groups_flatten(), ntree_shader_groups_remove_muted_links(), ntree_shader_unlink_hidden_value_sockets(), ntreeCompositClearTags(), ntreeHasTree(), ntreeLocalize(), process_nodes_for_depsgraph(), register_node_type_cmp_group(), register_node_type_geo_group(), register_node_type_sh_group(), register_node_type_tex_group(), texture_nodes_fetch_images_for_pool(), blender::ed::space_node::ui_node_draw_input(), blender::ed::space_node::ui_node_draw_node(), and blender::ed::space_node::ui_node_link_items().

◆ NODE_GROUP_OUTPUT

NODE_GROUP_OUTPUT

◆ Noise

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Noise

Definition at line 120 of file NOD_static_types.h.

Referenced by FrsNoise_init(), and gpencil_modifier_type_init().

◆ NORMAL

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value NORMAL

◆ Normal

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Normal

◆ NORMAL_MAP

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value NORMAL_MAP

Definition at line 91 of file NOD_static_types.h.

◆ NormalMap

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value NormalMap

Definition at line 91 of file NOD_static_types.h.

◆ Output

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate World Output

◆ OUTPUT_WORLD

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate OUTPUT_WORLD

Definition at line 52 of file NOD_static_types.h.

◆ OutputWorld

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate OutputWorld

Definition at line 52 of file NOD_static_types.h.

◆ PARTICLE_INFO

in reality light always falls off quadratically PARTICLE_INFO

Definition at line 83 of file NOD_static_types.h.

◆ ParticleInfo

in reality light always falls off quadratically ParticleInfo

Definition at line 83 of file NOD_static_types.h.

◆ point

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a point

Definition at line 108 of file NOD_static_types.h.

Referenced by add_feather_vertex_exec(), BVHBuild::add_reference_points(), blender::ed::space_node::add_reroute_insert_socket_link(), add_vertex_extrude(), add_vertex_subdivide(), btGImpactCollisionAlgorithm::addContactPoint(), addPoint(), annotation_stroke_arrow_calc_points(), annotation_stroke_arrow_init_conv_point(), apply_lengths_iter(), apply_stroke_envelope(), ApplySnapResize(), ApplySnapRotation(), ApplySnapTranslation(), Freestyle::BoxGrid::assignCells(), Freestyle::SphericalGrid::assignCells(), base_surface_grids_write(), BKE_brush_sample_masktex(), BKE_brush_sample_tex_3d(), BKE_curvemap_remove_point(), BKE_curveprofile_move_handle(), BKE_curveprofile_move_point(), BKE_curveprofile_remove_point(), BKE_effectors_apply(), BKE_gpencil_stroke_join(), BKE_gpencil_stroke_trim(), BKE_mask_calc_handle_adjacent_interp(), BKE_mask_calc_handle_point(), BKE_mask_calc_handle_point_auto(), BKE_mask_calc_tangent_polyline(), BKE_mask_clipboard_copy_from_layer(), BKE_mask_clipboard_paste_to_layer(), BKE_mask_get_handle_point_adjacent(), BKE_mask_layer_evaluate_deform(), BKE_mask_point_add_uw(), BKE_mask_point_direction_switch(), BKE_mask_point_free(), BKE_mask_point_handle(), BKE_mask_point_handles_mode_get(), BKE_mask_point_normal(), BKE_mask_point_parent_matrix_get(), BKE_mask_point_segment_co(), BKE_mask_point_segment_diff(), BKE_mask_point_segment_feather_diff(), BKE_mask_point_select_set(), BKE_mask_point_select_set_handle(), BKE_mask_point_set_handle(), BKE_mask_point_sort_uw(), BKE_mask_point_weight(), BKE_mask_point_weight_scalar(), BKE_mask_spline_ensure_deform(), BKE_mask_spline_feather_points(), BKE_mask_spline_feather_resolution(), BKE_mask_spline_free(), BKE_mask_spline_point_next_bezt(), BKE_mask_spline_project_co(), BKE_mask_spline_resolution(), BKE_nurb_minmax(), boundInsert(), boundIntersectPoint(), PointCloud::Point::bounds_grow(), box_select_exec(), bpy_bm_geometry_intersect_face_point(), brush_add(), brush_length(), brush_puff(), bt_distance_point_plane(), bt_quantize_clamp(), btConvexHullShape(), btNearestPointInLineSegment(), blender::deg::DepsgraphNodeBuilder::build_mask(), blender::deg::DepsgraphRelationBuilder::build_mask(), calculate_autoscale_factor(), calculate_average_length(), blender::bke::curves::bezier::calculate_vector_handle(), check_sliding_handle_type(), circle_select_exec(), GHOST_WindowWin32::clientToScreen(), btPolyhedralContactClipping::clipFaceAgainstHull(), Freestyle::GridHelpers::closestPointOnPolygon(), SphereTriangleDetector::collide(), copy_particle_edit(), count_selected_keys(), createTransMaskingData(), createTransParticleVerts(), Freestyle::CulledOccluderSource::cullViewEdges(), Freestyle::ViewMapBuilder::CullViewEdges(), curvemap_make_table(), CurveProfile_buttons_layout(), dBoxBox2(), deflect_emitter_iter(), delete_exec(), delete_feather_points(), disconnect_hair(), dist_squared_to_looptri_uv_edges(), dist_to_sphere_shell(), Freestyle::distance2D(), Freestyle::GridHelpers::distancePointToPolygon(), do_lasso_select_mask(), do_particle_interpolation(), do_physical_effector(), do_texture_effector(), blender::io::alembic::ABCCurveWriter::do_write(), draw_frustum_bound_sphere_calc(), draw_single_handle(), draw_spline_points(), draw_track_path_keyframe_points(), draw_track_path_lines(), draw_track_path_points(), dynamic_paint_create_uv_surface_direct_cb(), dynamic_paint_create_uv_surface_neighbor_cb(), dynamic_paint_output_surface_image_paint_cb(), dynamic_paint_output_surface_image_wetmap_cb(), dynamic_paint_surface_pre_step_cb(), ED_mask_feather_find_nearest(), ED_mask_find_nearest_diff_point(), ED_mask_point_find_nearest(), ED_mask_select_toggle_all(), ED_mask_selected_minmax(), ED_mask_spline_select_check(), ED_mask_spline_select_set(), ED_transform_calc_gizmo_stats(), EDBM_unified_findnearest_from_raycast(), eff_calc_visibility(), ensure_edit_inner_points_count(), ensure_edit_tip_points_count(), libmv::EuclideanBundleCommonIntrinsics(), libmv::EuclideanIntersect(), libmv::EuclideanScaleToUnity(), blender::compositor::PlaneDistortMaskOperation::execute_pixel_sampled(), Freestyle::GridHelpers::expandProscenium(), filtcolum(), filtcolumf(), filtrow(), filtrowf(), Freestyle::BoxGrid::findCell(), Freestyle::SphericalGrid::findCell(), finSelectedSplinePoint(), flushTransParticles(), for_mouse_hit_keys(), foreach_mouse_hit_key_iter(), foreach_mouse_hit_point(), generate_perimeter_cap(), get_closest_vertex_to_point_in_nurbs(), get_effector_data(), get_effector_tot(), BCBezTriple::get_in_tangent(), BCBezTriple::get_out_tangent(), PointCloud::get_point(), BCBezTriple::get_tangent(), BVHSpatialSplit::get_unaligned_point(), get_updated_data_for_edge(), GIM_TRIANGLE::get_uv_parameters(), SphereTriangleDetector::getClosestPoints(), GHOST_SystemWin32::getCursorPosition(), gim_get_point_inertia(), gpencil_origin_set(), gpencil_snap_to_guide(), gpencil_stroke_copy_point(), handle_position_for_minmax(), hide_exec(), image_sample_apply(), imb_filterx(), IMB_filtery(), init_particle_interpolation(), Freestyle::insideProscenium(), libmv::InternalReprojectionError(), GIM_TRIANGLE::is_point_inside(), isect_sweeping_sphere_tri_v3(), btGeometryUtil::isPointInsidePlanes(), iterate_lengths_iter(), libmv_reprojectionErrorForImage(), libmv_reprojectionErrorForTrack(), libmv_reprojectionPointForTrack(), lineart_gpencil_generate(), M_Interpolate_poly_3d_calc(), marker_to_path_point(), mask_blend_read_data(), mask_blend_read_expand(), mask_blend_read_lib(), mask_blend_write(), mask_calc_point_handle(), mask_duplicate_exec(), mask_evaluate_apply_point_parent(), mask_feather_weight_clear_exec(), mask_foreach_id(), mask_has_selection(), mask_normals_make_consistent_exec(), mask_parent_clear_exec(), mask_parent_set_exec(), mask_point_scaled_handle(), mask_select_linked_pick_invoke(), mask_shape_key_feather_reset_exec(), mask_shape_key_rekey_exec(), mask_spline_point_next(), mask_spline_point_prev(), mask_spline_points_copy(), MaskHandleToTransData(), MaskPointToTransData(), merge_point(), GIM_AABB::merge_point(), mesh_remap_interp_poly_data_get(), mirror_point(), libmv::ModalSolver(), nearest_key_fn(), DISTANCE_PLANE_3D_FUNC::operator()(), Freestyle::BoxGrid::Transform::operator()(), Freestyle::SphericalGrid::Transform::operator()(), OVERLAY_extra_point(), paintcurve_point_get_closest(), particle_batch_cache_ensure_edit_inner_pos(), particle_batch_cache_ensure_edit_tip_pos(), patch_eval_bspline_weights(), pd_point_from_loc(), pd_point_from_particle(), pd_point_from_soft(), PE_apply_mirror(), PE_create_particle_edit(), PE_deselect_all_visible_ex(), PE_free_ptcache_edit(), PE_lasso_select(), PE_mirror_particle(), PE_mirror_x(), PE_mouse_particles(), pe_select_all_exec(), pe_update_hair_particle_edit_pointers(), PE_update_object(), PE_update_selection(), PlaneProject(), point_calculate_handle(), point_draw_handles(), POINT_IN_HULL(), point_init(), point_inside_ellipse(), point_is_selected(), libmv::EuclideanReconstruction::PointForTrack(), libmv::ProjectiveReconstruction::PointForTrack(), precalc_guides(), Freestyle::FEdgeXDetector::ProcessSilhouetteFace(), btTriangleRaycastCallback::processTriangle(), psys_cache_edit_paths(), psys_cache_edit_paths_iter(), btContactArray::push_contact(), gim_contact_array::push_contact(), btAxisSweep3Internal< BP_FP_INT_TYPE >::quantize(), quantize(), btQuantizedBvhTree::quantizePoint(), quantizeWithClamp(), blender::io::alembic::AbcCurveReader::read_mesh(), blender::io::usd::USDCurvesReader::read_mesh(), blender::io::usd::USDNurbsReader::read_mesh(), recalc_lengths(), BVH2::refit_primitives(), rekey_particle(), remove_doubles_exec(), remove_tagged_keys(), remove_tagged_particles(), reveal_exec(), rotate_around_center_v2(), scale_point_factor(), scale_point_to_length(), scale_points_to_length(), GHOST_WindowWin32::screenToClient(), SCULPT_brush_strength_factor(), select_action_apply(), select_exec(), select_key(), select_key_op(), select_keys(), select_less_keys(), select_more_keys(), select_random_exec(), select_root(), select_sliding_point(), select_tip(), seq_point_image_isect(), Freestyle::Operators::sequentialSplit(), set_handle_type_exec(), slide_point_check_initial_feather(), slide_point_customdata(), slide_point_delta_all_feather(), slide_point_modal(), slide_point_restore_spline(), slide_spline_curvature_customdata(), BVHSpatialSplit::split_point_primitive(), stroke_march_count(), stroke_march_next_point(), stroke_march_next_point_no_interp(), subdivide_particle(), blender::tests::TEST(), TestPointAgainstAabb2(), testVoronoiEdge(), track_mask_gpencil_layer_rasterize(), GIM_BOX_BOX_TRANSFORM_CACHE::transform(), transform(), undoptcache_free_data(), undoptcache_from_editcache(), undoptcache_to_editcache(), update_cut_data_for_all_nurbs(), update_cut_data_for_nurb(), update_velocities(), vnormal(), and wrap().

◆ POINT_INFO

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object POINT_INFO

Definition at line 85 of file NOD_static_types.h.

◆ PointInfo

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object PointInfo

Definition at line 85 of file NOD_static_types.h.

◆ red

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its red

◆ RGB

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine RGB

Definition at line 26 of file NOD_static_types.h.

◆ RGBTOBW

Group Output data from inside of a node group A color picker Mix two input colors RGBTOBW

Definition at line 30 of file NOD_static_types.h.

◆ RGBToBW

Group Output data from inside of a node group A color picker Mix two input colors RGBToBW

Definition at line 30 of file NOD_static_types.h.

◆ saturation

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its saturation

◆ SCRIPT

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces SCRIPT

Definition at line 93 of file NOD_static_types.h.

◆ Script

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Script

Definition at line 93 of file NOD_static_types.h.

◆ SEPARATE_COLOR

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed Float Map an input float to a curve and outputs a float value SEPARATE_COLOR

Definition at line 124 of file NOD_static_types.h.

◆ SeparateColor

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed Float Map an input float to a curve and outputs a float value SeparateColor

Definition at line 124 of file NOD_static_types.h.

◆ SeparateXYZ

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified SeparateXYZ

Definition at line 114 of file NOD_static_types.h.

◆ SEPXYZ

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified SEPXYZ

Definition at line 114 of file NOD_static_types.h.

◆ SH_NODE_BEVEL

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components SH_NODE_BEVEL

Definition at line 116 of file NOD_static_types.h.

Referenced by register_node_type_sh_bevel().

◆ SH_NODE_BLACKBODY

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated SH_NODE_BLACKBODY

Definition at line 89 of file NOD_static_types.h.

Referenced by register_node_type_sh_blackbody().

◆ SH_NODE_BRIGHTCONTRAST

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product SH_NODE_BRIGHTCONTRAST

Definition at line 34 of file NOD_static_types.h.

Referenced by register_node_type_sh_brightcontrast().

◆ SH_NODE_CAMERA

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input SH_NODE_CAMERA

Definition at line 38 of file NOD_static_types.h.

Referenced by register_node_type_sh_camera().

◆ SH_NODE_CLAMP

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position SH_NODE_CLAMP

Definition at line 40 of file NOD_static_types.h.

Referenced by register_node_type_sh_clamp().

◆ SH_NODE_COMBHSV_LEGACY

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space SH_NODE_COMBHSV_LEGACY

◆ SH_NODE_COMBRGB_LEGACY

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative SH_NODE_COMBRGB_LEGACY

◆ SH_NODE_CURVE_FLOAT

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed SH_NODE_CURVE_FLOAT

◆ SH_NODE_CURVE_VEC

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color SH_NODE_CURVE_VEC

◆ SH_NODE_EEVEE_SPECULAR

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model SH_NODE_EEVEE_SPECULAR

◆ SH_NODE_FRESNEL

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate World Output light color information to the scene s World SH_NODE_FRESNEL

Definition at line 54 of file NOD_static_types.h.

Referenced by register_node_type_sh_fresnel().

◆ SH_NODE_HUE_SAT

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue SH_NODE_HUE_SAT

Definition at line 47 of file NOD_static_types.h.

Referenced by register_node_type_sh_hue_sat().

◆ SH_NODE_INVERT

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation SH_NODE_INVERT

Definition at line 44 of file NOD_static_types.h.

Referenced by register_node_type_sh_invert().

◆ SH_NODE_MIX_RGB

Group Output data from inside of a node group A color picker SH_NODE_MIX_RGB

◆ SH_NODE_NORMAL

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value SH_NODE_NORMAL

◆ SH_NODE_NORMAL_MAP

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value SH_NODE_NORMAL_MAP

◆ SH_NODE_OUTPUT_WORLD

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate SH_NODE_OUTPUT_WORLD

◆ SH_NODE_PARTICLE_INFO

in reality light always falls off quadratically SH_NODE_PARTICLE_INFO

Definition at line 83 of file NOD_static_types.h.

Referenced by register_node_type_sh_particle_info().

◆ SH_NODE_POINT_INFO

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object SH_NODE_POINT_INFO

Definition at line 85 of file NOD_static_types.h.

Referenced by register_node_type_sh_point_info().

◆ SH_NODE_RGB

Group Output data from inside of a node group SH_NODE_RGB

◆ SH_NODE_RGBTOBW

Group Output data from inside of a node group A color picker Mix two input colors SH_NODE_RGBTOBW

◆ SH_NODE_SCRIPT

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces SH_NODE_SCRIPT

◆ SH_NODE_SEPARATE_COLOR

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction White Return a random value or color based on an input seed Float Map an input float to a curve and outputs a float value SH_NODE_SEPARATE_COLOR

◆ SH_NODE_SEPXYZ

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified SH_NODE_SEPXYZ

Definition at line 114 of file NOD_static_types.h.

Referenced by register_node_type_sh_sepxyz().

◆ SH_NODE_TEX_BRICK

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells SH_NODE_TEX_BRICK

Definition at line 104 of file NOD_static_types.h.

Referenced by register_node_type_sh_tex_brick().

◆ SH_NODE_TEX_COORD

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks SH_NODE_TEX_COORD

◆ SH_NODE_TEX_IMAGE

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block SH_NODE_TEX_IMAGE

◆ SH_NODE_TEX_NOISE

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture SH_NODE_TEX_NOISE

◆ SH_NODE_TEX_SKY

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture SH_NODE_TEX_SKY

Definition at line 96 of file NOD_static_types.h.

Referenced by blo_do_versions_290(), and register_node_type_sh_tex_sky().

◆ SH_NODE_TEX_VORONOI

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise SH_NODE_TEX_VORONOI

◆ SH_NODE_TEX_WAVE

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise SH_NODE_TEX_WAVE

◆ SH_NODE_TEX_WHITE_NOISE

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction SH_NODE_TEX_WHITE_NOISE

Definition at line 120 of file NOD_static_types.h.

Referenced by register_node_type_sh_tex_white_noise().

◆ SH_NODE_VECT_TRANSFORM

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes SH_NODE_VECT_TRANSFORM

Definition at line 108 of file NOD_static_types.h.

Referenced by register_node_type_sh_vect_transform().

◆ SH_NODE_VECTOR_DISPLACEMENT

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders SH_NODE_VECTOR_DISPLACEMENT

◆ SH_NODE_VECTOR_MATH

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum SH_NODE_VECTOR_MATH

◆ SH_NODE_VERTEX_COLOR

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels SH_NODE_VERTEX_COLOR

Definition at line 112 of file NOD_static_types.h.

Referenced by register_node_type_sh_vertex_color().

◆ SH_NODE_WIREFRAME

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud SH_NODE_WIREFRAME

Definition at line 87 of file NOD_static_types.h.

Referenced by register_node_type_sh_wireframe().

◆ stones

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as stones

Definition at line 102 of file NOD_static_types.h.

◆ TEX_BRICK

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells TEX_BRICK

Definition at line 104 of file NOD_static_types.h.

◆ TEX_COORD

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks TEX_COORD

Definition at line 106 of file NOD_static_types.h.

◆ TEX_IMAGE

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block TEX_IMAGE

◆ TEX_NOISE

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture TEX_NOISE

Definition at line 98 of file NOD_static_types.h.

Referenced by BKE_texture_dependsOnTime(), multitex(), and sculpt_fix_noise_tear().

◆ TEX_SKY

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture TEX_SKY

Definition at line 96 of file NOD_static_types.h.

◆ TEX_VORONOI

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise TEX_VORONOI

◆ TEX_WAVE

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise TEX_WAVE

Definition at line 100 of file NOD_static_types.h.

◆ TEX_WHITE_NOISE

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction TEX_WHITE_NOISE

Definition at line 120 of file NOD_static_types.h.

◆ TexBrick

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells TexBrick

Definition at line 104 of file NOD_static_types.h.

◆ TexCoord

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks TexCoord

Definition at line 106 of file NOD_static_types.h.

◆ TexImage

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block TexImage

Definition at line 94 of file NOD_static_types.h.

◆ TexNoise

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture TexNoise

Definition at line 98 of file NOD_static_types.h.

◆ TexSky

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture TexSky

Definition at line 96 of file NOD_static_types.h.

◆ Texture

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Texture

◆ TexVoronoi

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise TexVoronoi

Definition at line 102 of file NOD_static_types.h.

◆ TexWave

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise TexWave

Definition at line 100 of file NOD_static_types.h.

◆ TexWhiteNoise

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders Vector Displace the surface along an arbitrary direction TexWhiteNoise

Definition at line 120 of file NOD_static_types.h.

◆ Transform

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Transform

Definition at line 108 of file NOD_static_types.h.

◆ Value

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Value

Definition at line 47 of file NOD_static_types.h.

Referenced by blender::StdUnorderedMapWrapper< Key, Value >::add(), blender::StdUnorderedMapWrapper< Key, Value >::add_new(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::foreach_item(), blender::compositor::GaussianAlphaBlurBaseOperation::GaussianAlphaBlurBaseOperation(), blender::IntrusiveMapSlot< Key, Value, KeyInfo >::IntrusiveMapSlot(), blender::StdUnorderedMapWrapper< Key, Value >::lookup(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::lookup(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::lookup_as(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::lookup_default(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::lookup_default_as(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::lookup_or_add(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::lookup_or_add_as(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::lookup_or_add_cb(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::lookup_or_add_cb_as(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::lookup_or_add_default(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::lookup_or_add_default_as(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::lookup_ptr(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::lookup_ptr_as(), blender::color::mix_add(), blender::color::mix_alpha_add(), blender::color::mix_alpha_sub(), blender::color::mix_blend(), blender::color::mix_color(), blender::color::mix_colorburn(), blender::color::mix_colordodge(), blender::color::mix_darken(), blender::color::mix_difference(), blender::color::mix_exclusion(), blender::color::mix_hardlight(), blender::color::mix_hue(), blender::color::mix_lighten(), blender::color::mix_linearburn(), blender::color::mix_linearlight(), blender::color::mix_luminosity(), blender::color::mix_mul(), blender::color::mix_overlay(), blender::color::mix_pinlight(), blender::color::mix_saturation(), blender::color::mix_screen(), blender::color::mix_softlight(), blender::color::mix_sub(), blender::color::mix_vividlight(), blender::SimpleMapSlot< Key, Value >::occupy(), blender::IntrusiveMapSlot< Key, Value, KeyInfo >::occupy(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::MutableValueIterator::operator*(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::ValueIterator::operator*(), blender::threading::parallel_reduce(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::pop(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::pop_as(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::pop_default(), blender::Map< Key, Value, InlineBufferCapacity, ProbingStrategy, Hash, IsEqual, Slot, Allocator >::pop_default_as(), blender::SimpleMapSlot< Key, Value >::value(), blender::IntrusiveMapSlot< Key, Value, KeyInfo >::value(), and vpaint_blend().

◆ VECT_MATH

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum VECT_MATH

Definition at line 42 of file NOD_static_types.h.

◆ VECT_TRANSFORM

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes VECT_TRANSFORM

Definition at line 108 of file NOD_static_types.h.

◆ vector

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a vector

◆ VECTOR_DISPLACEMENT

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders VECTOR_DISPLACEMENT

Definition at line 118 of file NOD_static_types.h.

◆ VectorCurve

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color VectorCurve

Definition at line 36 of file NOD_static_types.h.

◆ VectorDisplacement

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its and Z components Generates normals with round corners and may slow down renders VectorDisplacement

Definition at line 118 of file NOD_static_types.h.

◆ VectorMath

Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum VectorMath

Definition at line 42 of file NOD_static_types.h.

◆ VectorTransform

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes VectorTransform

Definition at line 108 of file NOD_static_types.h.

◆ VERTEX_COLOR

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels VERTEX_COLOR

Definition at line 112 of file NOD_static_types.h.

◆ VertexColor

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels VertexColor

Definition at line 112 of file NOD_static_types.h.

◆ water

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as water

Definition at line 102 of file NOD_static_types.h.

◆ WIREFRAME

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud WIREFRAME

Definition at line 87 of file NOD_static_types.h.

◆ Wireframe

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Wireframe

Definition at line 87 of file NOD_static_types.h.

Referenced by modifier_type_init().

◆ world

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between world

Definition at line 108 of file NOD_static_types.h.

◆ X

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its X

◆ XYZ

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate XYZ

Definition at line 114 of file NOD_static_types.h.

◆ Y

in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object for example to give variation to multiple instances of an object Point Retrieve information about points in a point cloud Retrieve the edges of an object as it appears to Cycles topology will always appear triangulated Convert a blackbody temperature to an RGB value Normal Generate a perturbed normal from an RGB normal map image Typically used for faking highly detailed surfaces Generate an OSL shader from a file or text data block Image Sample an image file as a texture Sky Generate a procedural sky texture Noise Generate fractal Perlin noise Wave Generate procedural bands or rings with noise Voronoi Generate Worley noise based on the distance to random points Typically used to generate textures such as or biological cells Brick Generate a procedural texture producing bricks Texture Retrieve multiple types of texture coordinates nTypically used as inputs for texture nodes Vector Convert a or normal between and object coordinate space Combine Create a color from its and value channels Color Retrieve a color or the default fallback if none is specified Separate Split a vector into its Y