snd class

" Static class

Exposes all nodes as static methods:

a = snd.math(1, 2, operation='ADD')

Source code in core/generated/static_snd.py

class SND:
    """" Static class

    Exposes all nodes as static methods:

    ``` python
    a = snd.math(1, 2, operation='ADD')
    ```
    """

    @classmethod
    def menu_switch(cls,
                    named_sockets: dict = {},
                    menu = None,
                    data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'MENU', 'SHADER', 'BUNDLE', 'CLOSURE'] = 'RGBA',
                    **sockets):
        """ > Node Menu Switch

        Parameters
        ----------
        named_sockets : dict, default={}
            Sockets created with string names

        menu : Menu, optional
            Menu selection

        data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Menu', 'Shader', 'Bundle', 'Closure']
            parameter `data_type`

        sockets : dict, default={}
            Socket created with python name attributes

        Returns
        -------
        Color
            peer sockets: a_ (Boolean), b_ (Boolean)

        """
        node = Node('Menu Switch', {'Menu': menu, **named_sockets}, data_type=data_type, **sockets)
        return node._out

    @classmethod
    def repeat_input(cls, iterations: Integer = None):
        """ > Node Repeat Input

        Parameters
        ----------
        iterations : Integer, optional
            socket 'Iterations' (id: Iterations)


        Returns
        -------
        Integer
        """
        node = Node('Repeat Input', {'Iterations': iterations})
        return node._out

    @classmethod
    def repeat_output(cls, inspection_index = 0):
        """ > Node Repeat Output

        Parameters
        ----------
        inspection_index : int
            parameter `inspection_index`


        Returns
        -------
        None
        """
        node = Node('Repeat Output', inspection_index=inspection_index)
        return node._out

    @utils.classproperty
    def closure_input(self):
        """ > Node Closure Input

        Returns
        -------
        None
        """
        node = Node('Closure Input', )
        return node._out

    @classmethod
    def closure_output(cls, active_input_index = 0, active_output_index = 0, define_signature = False):
        """ > Node Closure Output

        Parameters
        ----------
        active_input_index : int
            parameter `active_input_index`

        active_output_index : int
            parameter `active_output_index`

        define_signature : bool
            parameter `define_signature`


        Returns
        -------
        Closure
        """
        node = Node('Closure Output', active_input_index=active_input_index, active_output_index=active_output_index, define_signature=define_signature)
        return node._out

    @classmethod
    def combine_bundle(cls, named_sockets: dict = {}, define_signature = False, **sockets):
        """ > Node Combine Bundle

        Parameters
        ----------
        named_sockets : dict, default={}
            Sockets created with string names

        define_signature : bool
            parameter `define_signature`

        sockets : dict, default={}
            Socket created with python name attributes

        Returns
        -------
        Bundle
        """
        node = Node('Combine Bundle', named_sockets, define_signature=define_signature, **sockets)
        return node._out

    @classmethod
    def evaluate_closure(cls,
                    closure: Closure = None,
                    active_input_index = 0,
                    active_output_index = 0,
                    define_signature = False):
        """ > Node Evaluate Closure

        Parameters
        ----------
        closure : Closure, optional
            socket 'Closure' (id: Closure)

        active_input_index : int
            parameter `active_input_index`

        active_output_index : int
            parameter `active_output_index`

        define_signature : bool
            parameter `define_signature`


        Returns
        -------
        None
        """
        node = Node('Evaluate Closure', {'Closure': closure}, active_input_index=active_input_index, active_output_index=active_output_index, define_signature=define_signature)
        return node._out

    @classmethod
    def frame(cls, label_size = 20, shrink = True, text = None):
        """ > Node Frame

        Parameters
        ----------
        label_size : int
            parameter `label_size`

        shrink : bool
            parameter `shrink`

        text : NoneType
            parameter `text`


        Returns
        -------
        None
        """
        node = Node('Frame', label_size=label_size, shrink=shrink, text=text)
        return node._out

    @utils.classproperty
    def group_input(self):
        """ > Node Group Input

        Returns
        -------
        None
        """
        node = Node('Group Input', )
        return node._out

    @classmethod
    def group_output(cls, is_active_output = True):
        """ > Node Group Output

        Parameters
        ----------
        is_active_output : bool
            parameter `is_active_output`


        Returns
        -------
        None
        """
        node = Node('Group Output', is_active_output=is_active_output)
        return node._out

    @classmethod
    def join_bundle(cls, *bundle: Bundle):
        """ > Node Join Bundle

        Parameters
        ----------
        bundle : Bundle, optional
            socket 'Bundle' (id: Bundle)


        Returns
        -------
        Bundle
        """
        node = Node('Join Bundle', {'Bundle': list(bundle)})
        return node._out

    @classmethod
    def reroute(cls, input: Color = None, socket_idname = 'NodeSocketColor'):
        """ > Node Reroute

        Parameters
        ----------
        input : Color, optional
            socket 'Input' (id: Input)

        socket_idname : str
            parameter `socket_idname`


        Returns
        -------
        Color
        """
        node = Node('Reroute', {'Input': input}, socket_idname=socket_idname)
        return node._out

    @classmethod
    def separate_bundle(cls,
                    named_sockets: dict = {},
                    bundle: Bundle = None,
                    define_signature = False,
                    **sockets):
        """ > Node Separate Bundle

        Parameters
        ----------
        named_sockets : dict, default={}
            Sockets created with string names

        bundle : Bundle, optional
            socket 'Bundle' (id: Bundle)

        define_signature : bool
            parameter `define_signature`

        sockets : dict, default={}
            Socket created with python name attributes

        Returns
        -------
        None
        """
        node = Node('Separate Bundle', {'Bundle': bundle, **named_sockets}, define_signature=define_signature, **sockets)
        return node

    @classmethod
    def add_shader(cls, shader: Shader = None, shader_1: Shader = None):
        """ > Node Add Shader

        Parameters
        ----------
        shader : Shader, optional
            socket 'Shader' (id: Shader)

        shader_1 : Shader, optional
            socket 'Shader' (id: Shader_001)


        Returns
        -------
        Shader
        """
        node = Node('Add Shader', {'Shader': shader, 'Shader_001': shader_1})
        return node._out

    @classmethod
    def ambient_occlusion(cls,
                    color: Color = None,
                    distance: Float = None,
                    normal: Vector = None,
                    inside = False,
                    only_local = False,
                    samples = 16):
        """ > Node Ambient Occlusion

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        distance : Float, optional
            socket 'Distance' (id: Distance)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        inside : bool
            parameter `inside`

        only_local : bool
            parameter `only_local`

        samples : int
            parameter `samples`


        Returns
        -------
        Color
            peer sockets: ao_ (Float)

        """
        node = Node('Ambient Occlusion', {'Color': color, 'Distance': distance, 'Normal': normal}, inside=inside, only_local=only_local, samples=samples)
        return node._out

    @classmethod
    def attribute(cls,
                    attribute_name = '',
                    attribute_type: Literal['GEOMETRY', 'OBJECT', 'INSTANCER', 'VIEW_LAYER'] = 'GEOMETRY'):
        """ > Node Attribute

        Parameters
        ----------
        attribute_name : str
            parameter `attribute_name`

        attribute_type : Literal['Geometry', 'Object', 'Instancer', 'View Layer']
            parameter `attribute_type`


        Returns
        -------
        Color
            peer sockets: vector_ (Vector), factor_ (Float), alpha_ (Float)

        """
        utils.check_enum_arg('Attribute', 'attribute_type', attribute_type, 'attribute', ('GEOMETRY', 'OBJECT', 'INSTANCER', 'VIEW_LAYER'))
        node = Node('Attribute', attribute_name=attribute_name, attribute_type=attribute_type)
        return node

    @classmethod
    def background(cls, color: Color = None, strength: Float = None, weight: Float = None):
        """ > Node Background

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        strength : Float, optional
            socket 'Strength' (id: Strength)

        weight : Float, optional
            socket 'Weight' (id: Weight)


        Returns
        -------
        Shader
        """
        node = Node('Background', {'Color': color, 'Strength': strength, 'Weight': weight})
        return node._out

    @classmethod
    def bevel(cls, radius: Float = None, normal: Vector = None, samples = 4):
        """ > Node Bevel

        Parameters
        ----------
        radius : Float, optional
            socket 'Radius' (id: Radius)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        samples : int
            parameter `samples`


        Returns
        -------
        Vector
        """
        node = Node('Bevel', {'Radius': radius, 'Normal': normal}, samples=samples)
        return node._out

    @classmethod
    def blackbody(cls, temperature: Float = None):
        """ > Node Blackbody

        Parameters
        ----------
        temperature : Float, optional
            socket 'Temperature' (id: Temperature)


        Returns
        -------
        Color
        """
        node = Node('Blackbody', {'Temperature': temperature})
        return node._out

    @classmethod
    def brightness_contrast(cls, color: Color = None, brightness: Float = None, contrast: Float = None):
        """ > Node Brightness/Contrast

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        brightness : Float, optional
            socket 'Brightness' (id: Bright)

        contrast : Float, optional
            socket 'Contrast' (id: Contrast)


        Returns
        -------
        Color
        """
        node = Node('Brightness/Contrast', {'Color': color, 'Bright': brightness, 'Contrast': contrast})
        return node._out

    @classmethod
    def glossy_bsdf(cls,
                    color: Color = None,
                    roughness: Float = None,
                    anisotropy: Float = None,
                    rotation: Float = None,
                    normal: Vector = None,
                    tangent: Vector = None,
                    weight: Float = None,
                    distribution: Literal['BECKMANN', 'GGX', 'ASHIKHMIN_SHIRLEY', 'MULTI_GGX'] = 'MULTI_GGX'):
        """ > Node Glossy BSDF

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        roughness : Float, optional
            socket 'Roughness' (id: Roughness)

        anisotropy : Float, optional
            socket 'Anisotropy' (id: Anisotropy)

        rotation : Float, optional
            socket 'Rotation' (id: Rotation)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        tangent : Vector, optional
            socket 'Tangent' (id: Tangent)

        weight : Float, optional
            socket 'Weight' (id: Weight)

        distribution : Literal['Beckmann', 'GGX', 'Ashikhmin-Shirley', 'Multiscatter GGX']
            parameter `distribution`


        Returns
        -------
        Shader
        """
        utils.check_enum_arg('Glossy BSDF', 'distribution', distribution, 'glossy_bsdf', ('BECKMANN', 'GGX', 'ASHIKHMIN_SHIRLEY', 'MULTI_GGX'))
        node = Node('Glossy BSDF', {'Color': color, 'Roughness': roughness, 'Anisotropy': anisotropy, 'Rotation': rotation, 'Normal': normal, 'Tangent': tangent, 'Weight': weight}, distribution=distribution)
        return node._out

    @classmethod
    def diffuse_bsdf(cls,
                    color: Color = None,
                    roughness: Float = None,
                    normal: Vector = None,
                    weight: Float = None):
        """ > Node Diffuse BSDF

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        roughness : Float, optional
            socket 'Roughness' (id: Roughness)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        weight : Float, optional
            socket 'Weight' (id: Weight)


        Returns
        -------
        Shader
        """
        node = Node('Diffuse BSDF', {'Color': color, 'Roughness': roughness, 'Normal': normal, 'Weight': weight})
        return node._out

    @classmethod
    def glass_bsdf(cls,
                    color: Color = None,
                    roughness: Float = None,
                    ior: Float = None,
                    normal: Vector = None,
                    weight: Float = None,
                    thin_film_thickness: Float = None,
                    thin_film_ior: Float = None,
                    distribution: Literal['BECKMANN', 'GGX', 'MULTI_GGX'] = 'MULTI_GGX'):
        """ > Node Glass BSDF

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        roughness : Float, optional
            socket 'Roughness' (id: Roughness)

        ior : Float, optional
            socket 'IOR' (id: IOR)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        weight : Float, optional
            socket 'Weight' (id: Weight)

        thin_film_thickness : Float, optional
            socket 'Thin Film Thickness' (id: Thin Film Thickness)

        thin_film_ior : Float, optional
            socket 'Thin Film IOR' (id: Thin Film IOR)

        distribution : Literal['Beckmann', 'GGX', 'Multiscatter GGX']
            parameter `distribution`


        Returns
        -------
        Shader
        """
        utils.check_enum_arg('Glass BSDF', 'distribution', distribution, 'glass_bsdf', ('BECKMANN', 'GGX', 'MULTI_GGX'))
        node = Node('Glass BSDF', {'Color': color, 'Roughness': roughness, 'IOR': ior, 'Normal': normal, 'Weight': weight, 'Thin Film Thickness': thin_film_thickness, 'Thin Film IOR': thin_film_ior}, distribution=distribution)
        return node._out

    @classmethod
    def hair_bsdf(cls,
                    color: Color = None,
                    offset: Float = None,
                    roughnessu: Float = None,
                    roughnessv: Float = None,
                    tangent: Vector = None,
                    weight: Float = None,
                    component: Literal['Reflection', 'Transmission'] = 'Reflection'):
        """ > Node Hair BSDF

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        offset : Float, optional
            socket 'Offset' (id: Offset)

        roughnessu : Float, optional
            socket 'RoughnessU' (id: RoughnessU)

        roughnessv : Float, optional
            socket 'RoughnessV' (id: RoughnessV)

        tangent : Vector, optional
            socket 'Tangent' (id: Tangent)

        weight : Float, optional
            socket 'Weight' (id: Weight)

        component : Literal['Reflection', 'Transmission']
            parameter `component`


        Returns
        -------
        Shader
        """
        utils.check_enum_arg('Hair BSDF', 'component', component, 'hair_bsdf', ('Reflection', 'Transmission'))
        node = Node('Hair BSDF', {'Color': color, 'Offset': offset, 'RoughnessU': roughnessu, 'RoughnessV': roughnessv, 'Tangent': tangent, 'Weight': weight}, component=component)
        return node._out

    @classmethod
    def principled_hair_bsdf(cls,
                    color: Color = None,
                    melanin: Float = None,
                    melanin_redness: Float = None,
                    tint: Color = None,
                    absorption_coefficient: Vector = None,
                    aspect_ratio: Float = None,
                    roughness: Float = None,
                    radial_roughness: Float = None,
                    coat: Float = None,
                    ior: Float = None,
                    offset: Float = None,
                    random_color: Float = None,
                    random_roughness: Float = None,
                    random: Float = None,
                    weight: Float = None,
                    reflection: Float = None,
                    transmission: Float = None,
                    secondary_reflection: Float = None,
                    model: Literal['CHIANG', 'HUANG'] = 'CHIANG',
                    parametrization: Literal['ABSORPTION', 'MELANIN', 'COLOR'] = 'COLOR'):
        """ > Node Principled Hair BSDF

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        melanin : Float, optional
            socket 'Melanin' (id: Melanin)

        melanin_redness : Float, optional
            socket 'Melanin Redness' (id: Melanin Redness)

        tint : Color, optional
            socket 'Tint' (id: Tint)

        absorption_coefficient : Vector, optional
            socket 'Absorption Coefficient' (id: Absorption Coefficient)

        aspect_ratio : Float, optional
            socket 'Aspect Ratio' (id: Aspect Ratio)

        roughness : Float, optional
            socket 'Roughness' (id: Roughness)

        radial_roughness : Float, optional
            socket 'Radial Roughness' (id: Radial Roughness)

        coat : Float, optional
            socket 'Coat' (id: Coat)

        ior : Float, optional
            socket 'IOR' (id: IOR)

        offset : Float, optional
            socket 'Offset' (id: Offset)

        random_color : Float, optional
            socket 'Random Color' (id: Random Color)

        random_roughness : Float, optional
            socket 'Random Roughness' (id: Random Roughness)

        random : Float, optional
            socket 'Random' (id: Random)

        weight : Float, optional
            socket 'Weight' (id: Weight)

        reflection : Float, optional
            socket 'Reflection' (id: R lobe)

        transmission : Float, optional
            socket 'Transmission' (id: TT lobe)

        secondary_reflection : Float, optional
            socket 'Secondary Reflection' (id: TRT lobe)

        model : Literal['Chiang', 'Huang']
            parameter `model`

        parametrization : Literal['Absorption Coefficient', 'Melanin Concentration', 'Direct Coloring']
            parameter `parametrization`


        Returns
        -------
        Shader
        """
        utils.check_enum_arg('Principled Hair BSDF', 'model', model, 'principled_hair_bsdf', ('CHIANG', 'HUANG'))
        utils.check_enum_arg('Principled Hair BSDF', 'parametrization', parametrization, 'principled_hair_bsdf', ('ABSORPTION', 'MELANIN', 'COLOR'))
        node = Node('Principled Hair BSDF', {'Color': color, 'Melanin': melanin, 'Melanin Redness': melanin_redness, 'Tint': tint, 'Absorption Coefficient': absorption_coefficient, 'Aspect Ratio': aspect_ratio, 'Roughness': roughness, 'Radial Roughness': radial_roughness, 'Coat': coat, 'IOR': ior, 'Offset': offset, 'Random Color': random_color, 'Random Roughness': random_roughness, 'Random': random, 'Weight': weight, 'R lobe': reflection, 'TT lobe': transmission, 'TRT lobe': secondary_reflection}, model=model, parametrization=parametrization)
        return node._out

    @classmethod
    def metallic_bsdf(cls,
                    base_color: Color = None,
                    edge_tint: Color = None,
                    ior: Vector = None,
                    extinction: Vector = None,
                    roughness: Float = None,
                    anisotropy: Float = None,
                    rotation: Float = None,
                    normal: Vector = None,
                    tangent: Vector = None,
                    weight: Float = None,
                    thin_film_thickness: Float = None,
                    thin_film_ior: Float = None,
                    distribution: Literal['BECKMANN', 'GGX', 'MULTI_GGX'] = 'MULTI_GGX',
                    fresnel_type: Literal['PHYSICAL_CONDUCTOR', 'F82'] = 'F82'):
        """ > Node Metallic BSDF

        Parameters
        ----------
        base_color : Color, optional
            socket 'Base Color' (id: Base Color)

        edge_tint : Color, optional
            socket 'Edge Tint' (id: Edge Tint)

        ior : Vector, optional
            socket 'IOR' (id: IOR)

        extinction : Vector, optional
            socket 'Extinction' (id: Extinction)

        roughness : Float, optional
            socket 'Roughness' (id: Roughness)

        anisotropy : Float, optional
            socket 'Anisotropy' (id: Anisotropy)

        rotation : Float, optional
            socket 'Rotation' (id: Rotation)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        tangent : Vector, optional
            socket 'Tangent' (id: Tangent)

        weight : Float, optional
            socket 'Weight' (id: Weight)

        thin_film_thickness : Float, optional
            socket 'Thin Film Thickness' (id: Thin Film Thickness)

        thin_film_ior : Float, optional
            socket 'Thin Film IOR' (id: Thin Film IOR)

        distribution : Literal['Beckmann', 'GGX', 'Multiscatter GGX']
            parameter `distribution`

        fresnel_type : Literal['Physical Conductor', 'F82 Tint']
            parameter `fresnel_type`


        Returns
        -------
        Shader
        """
        utils.check_enum_arg('Metallic BSDF', 'distribution', distribution, 'metallic_bsdf', ('BECKMANN', 'GGX', 'MULTI_GGX'))
        utils.check_enum_arg('Metallic BSDF', 'fresnel_type', fresnel_type, 'metallic_bsdf', ('PHYSICAL_CONDUCTOR', 'F82'))
        node = Node('Metallic BSDF', {'Base Color': base_color, 'Edge Tint': edge_tint, 'IOR': ior, 'Extinction': extinction, 'Roughness': roughness, 'Anisotropy': anisotropy, 'Rotation': rotation, 'Normal': normal, 'Tangent': tangent, 'Weight': weight, 'Thin Film Thickness': thin_film_thickness, 'Thin Film IOR': thin_film_ior}, distribution=distribution, fresnel_type=fresnel_type)
        return node._out

    @classmethod
    def principled_bsdf(cls,
                    base_color: Color = None,
                    metallic: Float = None,
                    roughness: Float = None,
                    ior: Float = None,
                    alpha: Float = None,
                    normal: Vector = None,
                    weight: Float = None,
                    diffuse_roughness: Float = None,
                    subsurface_weight: Float = None,
                    subsurface_radius: Vector = None,
                    subsurface_scale: Float = None,
                    subsurface_ior: Float = None,
                    subsurface_anisotropy: Float = None,
                    specular_ior_level: Float = None,
                    specular_tint: Color = None,
                    anisotropic: Float = None,
                    anisotropic_rotation: Float = None,
                    tangent: Vector = None,
                    transmission_weight: Float = None,
                    coat_weight: Float = None,
                    coat_roughness: Float = None,
                    coat_ior: Float = None,
                    coat_tint: Color = None,
                    coat_normal: Vector = None,
                    sheen_weight: Float = None,
                    sheen_roughness: Float = None,
                    sheen_tint: Color = None,
                    emission_color: Color = None,
                    emission_strength: Float = None,
                    thin_film_thickness: Float = None,
                    thin_film_ior: Float = None,
                    distribution: Literal['GGX', 'MULTI_GGX'] = 'MULTI_GGX',
                    subsurface_method: Literal['BURLEY', 'RANDOM_WALK', 'RANDOM_WALK_SKIN'] = 'RANDOM_WALK'):
        """ > Node Principled BSDF

        Parameters
        ----------
        base_color : Color, optional
            socket 'Base Color' (id: Base Color)

        metallic : Float, optional
            socket 'Metallic' (id: Metallic)

        roughness : Float, optional
            socket 'Roughness' (id: Roughness)

        ior : Float, optional
            socket 'IOR' (id: IOR)

        alpha : Float, optional
            socket 'Alpha' (id: Alpha)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        weight : Float, optional
            socket 'Weight' (id: Weight)

        diffuse_roughness : Float, optional
            socket 'Diffuse Roughness' (id: Diffuse Roughness)

        subsurface_weight : Float, optional
            socket 'Subsurface Weight' (id: Subsurface Weight)

        subsurface_radius : Vector, optional
            socket 'Subsurface Radius' (id: Subsurface Radius)

        subsurface_scale : Float, optional
            socket 'Subsurface Scale' (id: Subsurface Scale)

        subsurface_ior : Float, optional
            socket 'Subsurface IOR' (id: Subsurface IOR)

        subsurface_anisotropy : Float, optional
            socket 'Subsurface Anisotropy' (id: Subsurface Anisotropy)

        specular_ior_level : Float, optional
            socket 'Specular IOR Level' (id: Specular IOR Level)

        specular_tint : Color, optional
            socket 'Specular Tint' (id: Specular Tint)

        anisotropic : Float, optional
            socket 'Anisotropic' (id: Anisotropic)

        anisotropic_rotation : Float, optional
            socket 'Anisotropic Rotation' (id: Anisotropic Rotation)

        tangent : Vector, optional
            socket 'Tangent' (id: Tangent)

        transmission_weight : Float, optional
            socket 'Transmission Weight' (id: Transmission Weight)

        coat_weight : Float, optional
            socket 'Coat Weight' (id: Coat Weight)

        coat_roughness : Float, optional
            socket 'Coat Roughness' (id: Coat Roughness)

        coat_ior : Float, optional
            socket 'Coat IOR' (id: Coat IOR)

        coat_tint : Color, optional
            socket 'Coat Tint' (id: Coat Tint)

        coat_normal : Vector, optional
            socket 'Coat Normal' (id: Coat Normal)

        sheen_weight : Float, optional
            socket 'Sheen Weight' (id: Sheen Weight)

        sheen_roughness : Float, optional
            socket 'Sheen Roughness' (id: Sheen Roughness)

        sheen_tint : Color, optional
            socket 'Sheen Tint' (id: Sheen Tint)

        emission_color : Color, optional
            socket 'Emission Color' (id: Emission Color)

        emission_strength : Float, optional
            socket 'Emission Strength' (id: Emission Strength)

        thin_film_thickness : Float, optional
            socket 'Thin Film Thickness' (id: Thin Film Thickness)

        thin_film_ior : Float, optional
            socket 'Thin Film IOR' (id: Thin Film IOR)

        distribution : Literal['GGX', 'Multiscatter GGX']
            parameter `distribution`

        subsurface_method : Literal['Christensen-Burley', 'Random Walk', 'Random Walk (Skin)']
            parameter `subsurface_method`


        Returns
        -------
        Shader
        """
        utils.check_enum_arg('Principled BSDF', 'distribution', distribution, 'principled_bsdf', ('GGX', 'MULTI_GGX'))
        utils.check_enum_arg('Principled BSDF', 'subsurface_method', subsurface_method, 'principled_bsdf', ('BURLEY', 'RANDOM_WALK', 'RANDOM_WALK_SKIN'))
        node = Node('Principled BSDF', {'Base Color': base_color, 'Metallic': metallic, 'Roughness': roughness, 'IOR': ior, 'Alpha': alpha, 'Normal': normal, 'Weight': weight, 'Diffuse Roughness': diffuse_roughness, 'Subsurface Weight': subsurface_weight, 'Subsurface Radius': subsurface_radius, 'Subsurface Scale': subsurface_scale, 'Subsurface IOR': subsurface_ior, 'Subsurface Anisotropy': subsurface_anisotropy, 'Specular IOR Level': specular_ior_level, 'Specular Tint': specular_tint, 'Anisotropic': anisotropic, 'Anisotropic Rotation': anisotropic_rotation, 'Tangent': tangent, 'Transmission Weight': transmission_weight, 'Coat Weight': coat_weight, 'Coat Roughness': coat_roughness, 'Coat IOR': coat_ior, 'Coat Tint': coat_tint, 'Coat Normal': coat_normal, 'Sheen Weight': sheen_weight, 'Sheen Roughness': sheen_roughness, 'Sheen Tint': sheen_tint, 'Emission Color': emission_color, 'Emission Strength': emission_strength, 'Thin Film Thickness': thin_film_thickness, 'Thin Film IOR': thin_film_ior}, distribution=distribution, subsurface_method=subsurface_method)
        return node._out

    @classmethod
    def ray_portal_bsdf(cls,
                    color: Color = None,
                    position: Vector = None,
                    direction: Vector = None,
                    weight: Float = None):
        """ > Node Ray Portal BSDF

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        position : Vector, optional
            socket 'Position' (id: Position)

        direction : Vector, optional
            socket 'Direction' (id: Direction)

        weight : Float, optional
            socket 'Weight' (id: Weight)


        Returns
        -------
        Shader
        """
        node = Node('Ray Portal BSDF', {'Color': color, 'Position': position, 'Direction': direction, 'Weight': weight})
        return node._out

    @classmethod
    def refraction_bsdf(cls,
                    color: Color = None,
                    roughness: Float = None,
                    ior: Float = None,
                    normal: Vector = None,
                    weight: Float = None,
                    distribution: Literal['BECKMANN', 'GGX'] = 'BECKMANN'):
        """ > Node Refraction BSDF

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        roughness : Float, optional
            socket 'Roughness' (id: Roughness)

        ior : Float, optional
            socket 'IOR' (id: IOR)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        weight : Float, optional
            socket 'Weight' (id: Weight)

        distribution : Literal['Beckmann', 'GGX']
            parameter `distribution`


        Returns
        -------
        Shader
        """
        utils.check_enum_arg('Refraction BSDF', 'distribution', distribution, 'refraction_bsdf', ('BECKMANN', 'GGX'))
        node = Node('Refraction BSDF', {'Color': color, 'Roughness': roughness, 'IOR': ior, 'Normal': normal, 'Weight': weight}, distribution=distribution)
        return node._out

    @classmethod
    def sheen_bsdf(cls,
                    color: Color = None,
                    roughness: Float = None,
                    normal: Vector = None,
                    weight: Float = None,
                    distribution: Literal['ASHIKHMIN', 'MICROFIBER'] = 'MICROFIBER'):
        """ > Node Sheen BSDF

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        roughness : Float, optional
            socket 'Roughness' (id: Roughness)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        weight : Float, optional
            socket 'Weight' (id: Weight)

        distribution : Literal['Ashikhmin', 'Microfiber']
            parameter `distribution`


        Returns
        -------
        Shader
        """
        utils.check_enum_arg('Sheen BSDF', 'distribution', distribution, 'sheen_bsdf', ('ASHIKHMIN', 'MICROFIBER'))
        node = Node('Sheen BSDF', {'Color': color, 'Roughness': roughness, 'Normal': normal, 'Weight': weight}, distribution=distribution)
        return node._out

    @classmethod
    def toon_bsdf(cls,
                    color: Color = None,
                    size: Float = None,
                    smooth: Float = None,
                    normal: Vector = None,
                    weight: Float = None,
                    component: Literal['DIFFUSE', 'GLOSSY'] = 'DIFFUSE'):
        """ > Node Toon BSDF

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        size : Float, optional
            socket 'Size' (id: Size)

        smooth : Float, optional
            socket 'Smooth' (id: Smooth)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        weight : Float, optional
            socket 'Weight' (id: Weight)

        component : Literal['Diffuse', 'Glossy']
            parameter `component`


        Returns
        -------
        Shader
        """
        utils.check_enum_arg('Toon BSDF', 'component', component, 'toon_bsdf', ('DIFFUSE', 'GLOSSY'))
        node = Node('Toon BSDF', {'Color': color, 'Size': size, 'Smooth': smooth, 'Normal': normal, 'Weight': weight}, component=component)
        return node._out

    @classmethod
    def translucent_bsdf(cls, color: Color = None, normal: Vector = None, weight: Float = None):
        """ > Node Translucent BSDF

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        weight : Float, optional
            socket 'Weight' (id: Weight)


        Returns
        -------
        Shader
        """
        node = Node('Translucent BSDF', {'Color': color, 'Normal': normal, 'Weight': weight})
        return node._out

    @classmethod
    def transparent_bsdf(cls, color: Color = None, weight: Float = None):
        """ > Node Transparent BSDF

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        weight : Float, optional
            socket 'Weight' (id: Weight)


        Returns
        -------
        Shader
        """
        node = Node('Transparent BSDF', {'Color': color, 'Weight': weight})
        return node._out

    @classmethod
    def bump(cls,
                    strength: Float = None,
                    distance: Float = None,
                    filter_width: Float = None,
                    height: Float = None,
                    normal: Vector = None,
                    invert = False):
        """ > Node Bump

        Parameters
        ----------
        strength : Float, optional
            socket 'Strength' (id: Strength)

        distance : Float, optional
            socket 'Distance' (id: Distance)

        filter_width : Float, optional
            socket 'Filter Width' (id: Filter Width)

        height : Float, optional
            socket 'Height' (id: Height)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        invert : bool
            parameter `invert`


        Returns
        -------
        Vector
        """
        node = Node('Bump', {'Strength': strength, 'Distance': distance, 'Filter Width': filter_width, 'Height': height, 'Normal': normal}, invert=invert)
        return node._out

    @classmethod
    def camera_data(cls):
        """ > Node Camera Data

        Returns
        -------
        Vector
            peer sockets: view_z_depth_ (Float), view_distance_ (Float)

        """
        node = Node('Camera Data', )
        return node

    @classmethod
    def clamp(cls,
                    value: Float = None,
                    min: Float = None,
                    max: Float = None,
                    clamp_type: Literal['MINMAX', 'RANGE'] = 'MINMAX'):
        """ > Node Clamp

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        min : Float, optional
            socket 'Min' (id: Min)

        max : Float, optional
            socket 'Max' (id: Max)

        clamp_type : Literal['Min Max', 'Range']
            parameter `clamp_type`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('Clamp', 'clamp_type', clamp_type, 'clamp', ('MINMAX', 'RANGE'))
        node = Node('Clamp', {'Value': value, 'Min': min, 'Max': max}, clamp_type=clamp_type)
        return node._out

    @classmethod
    def combine_color(cls,
                    red: Float = None,
                    green: Float = None,
                    blue: Float = None,
                    mode: Literal['RGB', 'HSV', 'HSL'] = 'RGB'):
        """ > Node Combine Color

        Parameters
        ----------
        red : Float, optional
            socket 'Red' (id: Red)

        green : Float, optional
            socket 'Green' (id: Green)

        blue : Float, optional
            socket 'Blue' (id: Blue)

        mode : Literal['RGB', 'HSV', 'HSL']
            parameter `mode`


        Returns
        -------
        Color
        """
        utils.check_enum_arg('Combine Color', 'mode', mode, 'combine_color', ('RGB', 'HSV', 'HSL'))
        node = Node('Combine Color', {'Red': red, 'Green': green, 'Blue': blue}, mode=mode)
        return node._out

    @classmethod
    def combine_xyz(cls, x: Float = None, y: Float = None, z: Float = None):
        """ > Node Combine XYZ

        Parameters
        ----------
        x : Float, optional
            socket 'X' (id: X)

        y : Float, optional
            socket 'Y' (id: Y)

        z : Float, optional
            socket 'Z' (id: Z)


        Returns
        -------
        Vector
        """
        node = Node('Combine XYZ', {'X': x, 'Y': y, 'Z': z})
        return node._out

    @classmethod
    def displacement(cls,
                    height: Float = None,
                    midlevel: Float = None,
                    scale: Float = None,
                    normal: Vector = None,
                    space: Literal['OBJECT', 'WORLD'] = 'OBJECT'):
        """ > Node Displacement

        Parameters
        ----------
        height : Float, optional
            socket 'Height' (id: Height)

        midlevel : Float, optional
            socket 'Midlevel' (id: Midlevel)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        space : Literal['Object Space', 'World Space']
            parameter `space`


        Returns
        -------
        Vector
        """
        utils.check_enum_arg('Displacement', 'space', space, 'displacement', ('OBJECT', 'WORLD'))
        node = Node('Displacement', {'Height': height, 'Midlevel': midlevel, 'Scale': scale, 'Normal': normal}, space=space)
        return node._out

    @classmethod
    def specular_bsdf(cls,
                    base_color: Color = None,
                    specular: Color = None,
                    roughness: Float = None,
                    emissive_color: Color = None,
                    transparency: Float = None,
                    normal: Vector = None,
                    clear_coat: Float = None,
                    clear_coat_roughness: Float = None,
                    clear_coat_normal: Vector = None,
                    weight: Float = None):
        """ > Node Specular BSDF

        Parameters
        ----------
        base_color : Color, optional
            socket 'Base Color' (id: Base Color)

        specular : Color, optional
            socket 'Specular' (id: Specular)

        roughness : Float, optional
            socket 'Roughness' (id: Roughness)

        emissive_color : Color, optional
            socket 'Emissive Color' (id: Emissive Color)

        transparency : Float, optional
            socket 'Transparency' (id: Transparency)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        clear_coat : Float, optional
            socket 'Clear Coat' (id: Clear Coat)

        clear_coat_roughness : Float, optional
            socket 'Clear Coat Roughness' (id: Clear Coat Roughness)

        clear_coat_normal : Vector, optional
            socket 'Clear Coat Normal' (id: Clear Coat Normal)

        weight : Float, optional
            socket 'Weight' (id: Weight)


        Returns
        -------
        Shader
        """
        node = Node('Specular BSDF', {'Base Color': base_color, 'Specular': specular, 'Roughness': roughness, 'Emissive Color': emissive_color, 'Transparency': transparency, 'Normal': normal, 'Clear Coat': clear_coat, 'Clear Coat Roughness': clear_coat_roughness, 'Clear Coat Normal': clear_coat_normal, 'Weight': weight})
        return node._out

    @classmethod
    def emission(cls, color: Color = None, strength: Float = None, weight: Float = None):
        """ > Node Emission

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        strength : Float, optional
            socket 'Strength' (id: Strength)

        weight : Float, optional
            socket 'Weight' (id: Weight)


        Returns
        -------
        Shader
        """
        node = Node('Emission', {'Color': color, 'Strength': strength, 'Weight': weight})
        return node._out

    @classmethod
    def float_curve(cls, value: Float = None, factor: Float = None):
        """ > Node Float Curve

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        factor : Float, optional
            socket 'Factor' (id: Factor)


        Returns
        -------
        Float
        """
        node = NodeCurves('Float Curve', {'Value': value, 'Factor': factor})
        return node._out

    @classmethod
    def fresnel(cls, ior: Float = None, normal: Vector = None):
        """ > Node Fresnel

        Parameters
        ----------
        ior : Float, optional
            socket 'IOR' (id: IOR)

        normal : Vector, optional
            socket 'Normal' (id: Normal)


        Returns
        -------
        Float
        """
        node = Node('Fresnel', {'IOR': ior, 'Normal': normal})
        return node._out

    @classmethod
    def gamma(cls, color: Color = None, gamma: Float = None):
        """ > Node Gamma

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        gamma : Float, optional
            socket 'Gamma' (id: Gamma)


        Returns
        -------
        Color
        """
        node = Node('Gamma', {'Color': color, 'Gamma': gamma})
        return node._out

    @classmethod
    def group(cls, node_tree = None):
        """ > Node Group

        Parameters
        ----------
        node_tree : NoneType
            parameter `node_tree`


        Returns
        -------
        None
        """
        node = Node('Group', node_tree=node_tree)
        return node._out

    @classmethod
    def curves_info(cls):
        """ > Node Curves Info

        Returns
        -------
        Float
            peer sockets: intercept_ (Float), length_ (Float), thickness_ (Float), tangent_normal_ (Vector), random_ (Float)

        """
        node = Node('Curves Info', )
        return node

    @classmethod
    def holdout(cls, weight: Float = None):
        """ > Node Holdout

        Parameters
        ----------
        weight : Float, optional
            socket 'Weight' (id: Weight)


        Returns
        -------
        Shader
        """
        node = Node('Holdout', {'Weight': weight})
        return node._out

    @classmethod
    def hue_saturation_value(cls,
                    hue: Float = None,
                    saturation: Float = None,
                    value: Float = None,
                    color: Color = None,
                    factor: Float = None):
        """ > Node Hue/Saturation/Value

        Parameters
        ----------
        hue : Float, optional
            socket 'Hue' (id: Hue)

        saturation : Float, optional
            socket 'Saturation' (id: Saturation)

        value : Float, optional
            socket 'Value' (id: Value)

        color : Color, optional
            socket 'Color' (id: Color)

        factor : Float, optional
            socket 'Factor' (id: Fac)


        Returns
        -------
        Color
        """
        node = Node('Hue/Saturation/Value', {'Hue': hue, 'Saturation': saturation, 'Value': value, 'Color': color, 'Fac': factor})
        return node._out

    @classmethod
    def invert_color(cls, color: Color = None, factor: Float = None):
        """ > Node Invert Color

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        factor : Float, optional
            socket 'Factor' (id: Fac)


        Returns
        -------
        Color
        """
        node = Node('Invert Color', {'Color': color, 'Fac': factor})
        return node._out

    @classmethod
    def layer_weight(cls, blend: Float = None, normal: Vector = None):
        """ > Node Layer Weight

        Parameters
        ----------
        blend : Float, optional
            socket 'Blend' (id: Blend)

        normal : Vector, optional
            socket 'Normal' (id: Normal)


        Returns
        -------
        Float
            peer sockets: facing_ (Float)

        """
        node = Node('Layer Weight', {'Blend': blend, 'Normal': normal})
        return node._out

    @classmethod
    def light_falloff(cls, strength: Float = None, smooth: Float = None):
        """ > Node Light Falloff

        Parameters
        ----------
        strength : Float, optional
            socket 'Strength' (id: Strength)

        smooth : Float, optional
            socket 'Smooth' (id: Smooth)


        Returns
        -------
        Float
            peer sockets: linear_ (Float), constant_ (Float)

        """
        node = Node('Light Falloff', {'Strength': strength, 'Smooth': smooth})
        return node._out

    @classmethod
    def light_path(cls):
        """ > Node Light Path

        Returns
        -------
        Float
            peer sockets: is_shadow_ray_ (Float), is_diffuse_ray_ (Float), is_glossy_ray_ (Float), is_singular_ray_ (Float), is_reflection_ray_ (Float), is_transmission_ray_ (Float), is_volume_scatter_ray_ (Float), ray_length_ (Float), ray_depth_ (Float), diffuse_depth_ (Float), glossy_depth_ (Float), transparent_depth_ (Float), transmission_depth_ (Float), portal_depth_ (Float)

        """
        node = Node('Light Path', )
        return node

    @classmethod
    def map_range(cls,
                    value: Float = None,
                    from_min: Float = None,
                    from_max: Float = None,
                    to_min: Float = None,
                    to_max: Float = None,
                    steps: Float = None,
                    vector: Vector = None,
                    from_min_1: Vector = None,
                    from_max_1: Vector = None,
                    to_min_1: Vector = None,
                    to_max_1: Vector = None,
                    steps_1: Vector = None,
                    clamp = True,
                    data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
                    interpolation_type: Literal['LINEAR', 'STEPPED', 'SMOOTHSTEP', 'SMOOTHERSTEP'] = 'LINEAR'):
        """ > Node Map Range

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        from_min : Float, optional
            socket 'From Min' (id: From Min)

        from_max : Float, optional
            socket 'From Max' (id: From Max)

        to_min : Float, optional
            socket 'To Min' (id: To Min)

        to_max : Float, optional
            socket 'To Max' (id: To Max)

        steps : Float, optional
            socket 'Steps' (id: Steps)

        vector : Vector, optional
            socket 'Vector' (id: Vector)

        from_min_1 : Vector, optional
            socket 'From Min' (id: From_Min_FLOAT3)

        from_max_1 : Vector, optional
            socket 'From Max' (id: From_Max_FLOAT3)

        to_min_1 : Vector, optional
            socket 'To Min' (id: To_Min_FLOAT3)

        to_max_1 : Vector, optional
            socket 'To Max' (id: To_Max_FLOAT3)

        steps_1 : Vector, optional
            socket 'Steps' (id: Steps_FLOAT3)

        clamp : bool
            parameter `clamp`

        data_type : Literal['Float', 'Vector']
            parameter `data_type`

        interpolation_type : Literal['Linear', 'Stepped Linear', 'Smooth Step', 'Smoother Step']
            parameter `interpolation_type`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('Map Range', 'interpolation_type', interpolation_type, 'map_range', ('LINEAR', 'STEPPED', 'SMOOTHSTEP', 'SMOOTHERSTEP'))
        node = Node('Map Range', {'Value': value, 'From Min': from_min, 'From Max': from_max, 'To Min': to_min, 'To Max': to_max, 'Steps': steps, 'Vector': vector, 'From_Min_FLOAT3': from_min_1, 'From_Max_FLOAT3': from_max_1, 'To_Min_FLOAT3': to_min_1, 'To_Max_FLOAT3': to_max_1, 'Steps_FLOAT3': steps_1}, clamp=clamp, data_type=data_type, interpolation_type=interpolation_type)
        return node._out

    @classmethod
    def mapping(cls,
                    vector: Vector = None,
                    location: Vector = None,
                    rotation: Vector = None,
                    scale: Vector = None,
                    vector_type: Literal['POINT', 'TEXTURE', 'VECTOR', 'NORMAL'] = 'POINT'):
        """ > Node Mapping

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        location : Vector, optional
            socket 'Location' (id: Location)

        rotation : Vector, optional
            socket 'Rotation' (id: Rotation)

        scale : Vector, optional
            socket 'Scale' (id: Scale)

        vector_type : Literal['Point', 'Texture', 'Vector', 'Normal']
            parameter `vector_type`


        Returns
        -------
        Vector
        """
        utils.check_enum_arg('Mapping', 'vector_type', vector_type, 'mapping', ('POINT', 'TEXTURE', 'VECTOR', 'NORMAL'))
        node = Node('Mapping', {'Vector': vector, 'Location': location, 'Rotation': rotation, 'Scale': scale}, vector_type=vector_type)
        return node._out

    @classmethod
    def math(cls,
                    value: Float = None,
                    value_1: Float = None,
                    value_2: Float = None,
                    operation: Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'POWER', 'LOGARITHM', 'SQRT', 'INVERSE_SQRT', 'ABSOLUTE', 'EXPONENT', 'MINIMUM', 'MAXIMUM', 'LESS_THAN', 'GREATER_THAN', 'SIGN', 'COMPARE', 'SMOOTH_MIN', 'SMOOTH_MAX', 'ROUND', 'FLOOR', 'CEIL', 'TRUNC', 'FRACT', 'MODULO', 'FLOORED_MODULO', 'WRAP', 'SNAP', 'PINGPONG', 'SINE', 'COSINE', 'TANGENT', 'ARCSINE', 'ARCCOSINE', 'ARCTANGENT', 'ARCTAN2', 'SINH', 'COSH', 'TANH', 'RADIANS', 'DEGREES'] = 'ADD',
                    use_clamp = False):
        """ > Node Math

        Parameters
        ----------
        value : Float, optional
            socket 'Value' (id: Value)

        value_1 : Float, optional
            socket 'Value' (id: Value_001)

        value_2 : Float, optional
            socket 'Value' (id: Value_002)

        operation : Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Power', 'Logarithm', 'Square Root', 'Inverse Square Root', 'Absolute', 'Exponent', 'Minimum', 'Maximum', 'Less Than', 'Greater Than', 'Sign', 'Compare', 'Smooth Minimum', 'Smooth Maximum', 'Round', 'Floor', 'Ceil', 'Truncate', 'Fraction', 'Truncated Modulo', 'Floored Modulo', 'Wrap', 'Snap', 'Ping-Pong', 'Sine', 'Cosine', 'Tangent', 'Arcsine', 'Arccosine', 'Arctangent', 'Arctan2', 'Hyperbolic Sine', 'Hyperbolic Cosine', 'Hyperbolic Tangent', 'To Radians', 'To Degrees']
            parameter `operation`

        use_clamp : bool
            parameter `use_clamp`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('Math', 'operation', operation, 'math', ('ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'POWER', 'LOGARITHM', 'SQRT', 'INVERSE_SQRT', 'ABSOLUTE', 'EXPONENT', 'MINIMUM', 'MAXIMUM', 'LESS_THAN', 'GREATER_THAN', 'SIGN', 'COMPARE', 'SMOOTH_MIN', 'SMOOTH_MAX', 'ROUND', 'FLOOR', 'CEIL', 'TRUNC', 'FRACT', 'MODULO', 'FLOORED_MODULO', 'WRAP', 'SNAP', 'PINGPONG', 'SINE', 'COSINE', 'TANGENT', 'ARCSINE', 'ARCCOSINE', 'ARCTANGENT', 'ARCTAN2', 'SINH', 'COSH', 'TANH', 'RADIANS', 'DEGREES'))
        node = Node('Math', {'Value': value, 'Value_001': value_1, 'Value_002': value_2}, operation=operation, use_clamp=use_clamp)
        return node._out

    @classmethod
    def mix(cls,
                    a: Float = None,
                    b: Float = None,
                    a_1: Vector = None,
                    b_1: Vector = None,
                    a_2: Color = None,
                    b_2: Color = None,
                    a_3: Rotation = None,
                    b_3: Rotation = None,
                    factor: Vector = None,
                    blend_type: Literal['MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'] = 'MIX',
                    clamp_factor = True,
                    clamp_result = False,
                    data_type: Literal['FLOAT', 'VECTOR', 'RGBA'] = 'FLOAT',
                    factor_mode: Literal['UNIFORM', 'NON_UNIFORM'] = 'UNIFORM'):
        """ > Node Mix

        Parameters
        ----------
        a : Float, optional
            socket 'A' (id: A_Float)

        b : Float, optional
            socket 'B' (id: B_Float)

        a_1 : Vector, optional
            socket 'A' (id: A_Vector)

        b_1 : Vector, optional
            socket 'B' (id: B_Vector)

        a_2 : Color, optional
            socket 'A' (id: A_Color)

        b_2 : Color, optional
            socket 'B' (id: B_Color)

        a_3 : Rotation, optional
            socket 'A' (id: A_Rotation)

        b_3 : Rotation, optional
            socket 'B' (id: B_Rotation)

        factor : Vector, optional
            socket 'Factor' (id: Factor_Vector)

        blend_type : Literal['Mix', 'Darken', 'Multiply', 'Color Burn', 'Lighten', 'Screen', 'Color Dodge', 'Add', 'Overlay', 'Soft Light', 'Linear Light', 'Difference', 'Exclusion', 'Subtract', 'Divide', 'Hue', 'Saturation', 'Color', 'Value']
            parameter `blend_type`

        clamp_factor : bool
            parameter `clamp_factor`

        clamp_result : bool
            parameter `clamp_result`

        data_type : Literal['Float', 'Vector', 'Color']
            parameter `data_type`

        factor_mode : Literal['Uniform', 'Non-Uniform']
            parameter `factor_mode`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('Mix', 'blend_type', blend_type, 'mix', ('MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'))
        utils.check_enum_arg('Mix', 'factor_mode', factor_mode, 'mix', ('UNIFORM', 'NON_UNIFORM'))
        node = Node('Mix', {'A_Float': a, 'B_Float': b, 'A_Vector': a_1, 'B_Vector': b_1, 'A_Color': a_2, 'B_Color': b_2, 'A_Rotation': a_3, 'B_Rotation': b_3, 'Factor_Vector': factor}, blend_type=blend_type, clamp_factor=clamp_factor, clamp_result=clamp_result, data_type=data_type, factor_mode=factor_mode)
        return node._out

    @classmethod
    def mix_shader(cls, shader: Shader = None, shader_1: Shader = None, factor: Float = None):
        """ > Node Mix Shader

        Parameters
        ----------
        shader : Shader, optional
            socket 'Shader' (id: Shader)

        shader_1 : Shader, optional
            socket 'Shader' (id: Shader_001)

        factor : Float, optional
            socket 'Factor' (id: Fac)


        Returns
        -------
        Shader
        """
        node = Node('Mix Shader', {'Shader': shader, 'Shader_001': shader_1, 'Fac': factor})
        return node._out

    @classmethod
    def geometry(cls):
        """ > Node Geometry

        Returns
        -------
        Vector
            peer sockets: normal_ (Vector), tangent_ (Vector), true_normal_ (Vector), incoming_ (Vector), parametric_ (Vector), backfacing_ (Float), pointiness_ (Float), random_per_island_ (Float)

        """
        node = Node('Geometry', )
        return node

    @classmethod
    def normal(cls, normal: Vector = None):
        """ > Node Normal

        Parameters
        ----------
        normal : Vector, optional
            socket 'Normal' (id: Normal)


        Returns
        -------
        Vector
            peer sockets: dot_ (Float)

        """
        node = Node('Normal', {'Normal': normal})
        return node._out

    @classmethod
    def normal_map(cls,
                    strength: Float = None,
                    color: Color = None,
                    base: Literal['ORIGINAL', 'DISPLACED'] = 'DISPLACED',
                    convention: Literal['OPENGL', 'DIRECTX'] = 'OPENGL',
                    space: Literal['TANGENT', 'OBJECT', 'WORLD', 'BLENDER_OBJECT', 'BLENDER_WORLD'] = 'TANGENT',
                    uv_map = ''):
        """ > Node Normal Map

        Parameters
        ----------
        strength : Float, optional
            socket 'Strength' (id: Strength)

        color : Color, optional
            socket 'Color' (id: Color)

        base : Literal['Original Base', 'Displaced Base']
            parameter `base`

        convention : Literal['OpenGL', 'DirectX']
            parameter `convention`

        space : Literal['Tangent Space', 'Object Space', 'World Space', 'Blender Object Space', 'Blender World Space']
            parameter `space`

        uv_map : str
            parameter `uv_map`


        Returns
        -------
        Vector
        """
        utils.check_enum_arg('Normal Map', 'base', base, 'normal_map', ('ORIGINAL', 'DISPLACED'))
        utils.check_enum_arg('Normal Map', 'convention', convention, 'normal_map', ('OPENGL', 'DIRECTX'))
        utils.check_enum_arg('Normal Map', 'space', space, 'normal_map', ('TANGENT', 'OBJECT', 'WORLD', 'BLENDER_OBJECT', 'BLENDER_WORLD'))
        node = Node('Normal Map', {'Strength': strength, 'Color': color}, base=base, convention=convention, space=space, uv_map=uv_map)
        return node._out

    @classmethod
    def object_info(cls):
        """ > Node Object Info

        Returns
        -------
        Vector
            peer sockets: color_ (Color), alpha_ (Float), object_index_ (Float), material_index_ (Float), random_ (Float)

        """
        node = Node('Object Info', )
        return node

    @classmethod
    def aov_output(cls, color: Color = None, value: Float = None, aov_name = ''):
        """ > Node AOV Output

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        value : Float, optional
            socket 'Value' (id: Value)

        aov_name : str
            parameter `aov_name`


        Returns
        -------
        None
        """
        node = Node('AOV Output', {'Color': color, 'Value': value}, aov_name=aov_name)
        return node._out

    @classmethod
    def light_output(cls,
                    surface: Shader = None,
                    is_active_output = True,
                    target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL'):
        """ > Node Light Output

        Parameters
        ----------
        surface : Shader, optional
            socket 'Surface' (id: Surface)

        is_active_output : bool
            parameter `is_active_output`

        target : Literal['All', 'EEVEE', 'Cycles']
            parameter `target`


        Returns
        -------
        None
        """
        utils.check_enum_arg('Light Output', 'target', target, 'light_output', ('ALL', 'EEVEE', 'CYCLES'))
        node = Node('Light Output', {'Surface': surface}, is_active_output=is_active_output, target=target)
        return node._out

    @classmethod
    def line_style_output(cls,
                    color: Color = None,
                    color_fac: Float = None,
                    alpha: Float = None,
                    alpha_fac: Float = None,
                    blend_type: Literal['MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'] = 'MIX',
                    is_active_output = True,
                    target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL',
                    use_alpha = False,
                    use_clamp = False):
        """ > Node Line Style Output

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        color_fac : Float, optional
            socket 'Color Fac' (id: Color Fac)

        alpha : Float, optional
            socket 'Alpha' (id: Alpha)

        alpha_fac : Float, optional
            socket 'Alpha Fac' (id: Alpha Fac)

        blend_type : Literal['Mix', 'Darken', 'Multiply', 'Color Burn', 'Lighten', 'Screen', 'Color Dodge', 'Add', 'Overlay', 'Soft Light', 'Linear Light', 'Difference', 'Exclusion', 'Subtract', 'Divide', 'Hue', 'Saturation', 'Color', 'Value']
            parameter `blend_type`

        is_active_output : bool
            parameter `is_active_output`

        target : Literal['All', 'EEVEE', 'Cycles']
            parameter `target`

        use_alpha : bool
            parameter `use_alpha`

        use_clamp : bool
            parameter `use_clamp`


        Returns
        -------
        None
        """
        utils.check_enum_arg('Line Style Output', 'blend_type', blend_type, 'line_style_output', ('MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'))
        utils.check_enum_arg('Line Style Output', 'target', target, 'line_style_output', ('ALL', 'EEVEE', 'CYCLES'))
        node = Node('Line Style Output', {'Color': color, 'Color Fac': color_fac, 'Alpha': alpha, 'Alpha Fac': alpha_fac}, blend_type=blend_type, is_active_output=is_active_output, target=target, use_alpha=use_alpha, use_clamp=use_clamp)
        return node._out

    @classmethod
    def material_output(cls,
                    surface: Shader = None,
                    volume: VolumeShader = None,
                    displacement: Vector = None,
                    thickness: Float = None,
                    is_active_output = True,
                    target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL'):
        """ > Node Material Output

        Parameters
        ----------
        surface : Shader, optional
            socket 'Surface' (id: Surface)

        volume : VolumeShader, optional
            socket 'Volume' (id: Volume)

        displacement : Vector, optional
            socket 'Displacement' (id: Displacement)

        thickness : Float, optional
            socket 'Thickness' (id: Thickness)

        is_active_output : bool
            parameter `is_active_output`

        target : Literal['All', 'EEVEE', 'Cycles']
            parameter `target`


        Returns
        -------
        None
        """
        utils.check_enum_arg('Material Output', 'target', target, 'material_output', ('ALL', 'EEVEE', 'CYCLES'))
        node = Node('Material Output', {'Surface': surface, 'Volume': volume, 'Displacement': displacement, 'Thickness': thickness}, is_active_output=is_active_output, target=target)
        return node._out

    @classmethod
    def world_output(cls,
                    surface: Shader = None,
                    volume: VolumeShader = None,
                    is_active_output = True,
                    target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL'):
        """ > Node World Output

        Parameters
        ----------
        surface : Shader, optional
            socket 'Surface' (id: Surface)

        volume : VolumeShader, optional
            socket 'Volume' (id: Volume)

        is_active_output : bool
            parameter `is_active_output`

        target : Literal['All', 'EEVEE', 'Cycles']
            parameter `target`


        Returns
        -------
        None
        """
        utils.check_enum_arg('World Output', 'target', target, 'world_output', ('ALL', 'EEVEE', 'CYCLES'))
        node = Node('World Output', {'Surface': surface, 'Volume': volume}, is_active_output=is_active_output, target=target)
        return node._out

    @classmethod
    def particle_info(cls):
        """ > Node Particle Info

        Returns
        -------
        Float
            peer sockets: random_ (Float), age_ (Float), lifetime_ (Float), location_ (Vector), size_ (Float), velocity_ (Vector), angular_velocity_ (Vector)

        """
        node = Node('Particle Info', )
        return node

    @classmethod
    def point_info(cls):
        """ > Node Point Info

        Returns
        -------
        Vector
            peer sockets: radius_ (Float), random_ (Float)

        """
        node = Node('Point Info', )
        return node

    @utils.classproperty
    def color(self):
        """ > Node Color

        Returns
        -------
        Color
        """
        node = Node('Color', )
        return node._out

    @classmethod
    def rgb_curves(cls, color: Color = None, factor: Float = None):
        """ > Node RGB Curves

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        factor : Float, optional
            socket 'Factor' (id: Fac)


        Returns
        -------
        Color
        """
        node = NodeCurves('RGB Curves', {'Color': color, 'Fac': factor})
        return node._out

    @classmethod
    def rgb_to_bw(cls, color: Color = None):
        """ > Node RGB to BW

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)


        Returns
        -------
        Float
        """
        node = Node('RGB to BW', {'Color': color})
        return node._out

    @classmethod
    def radial_tiling(cls,
                    vector: Vector = None,
                    sides: Float = None,
                    roundness: Float = None,
                    normalize = False):
        """ > Node Radial Tiling

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        sides : Float, optional
            socket 'Sides' (id: Sides)

        roundness : Float, optional
            socket 'Roundness' (id: Roundness)

        normalize : bool
            parameter `normalize`


        Returns
        -------
        Vector
            peer sockets: segment_id_ (Float), segment_width_ (Float), segment_rotation_ (Float)

        """
        node = Node('Radial Tiling', {'Vector': vector, 'Sides': sides, 'Roundness': roundness}, normalize=normalize)
        return node._out

    @classmethod
    def raycast(cls,
                    position: Vector = None,
                    direction: Vector = None,
                    length: Float = None,
                    only_local = False):
        """ > Node Raycast

        Parameters
        ----------
        position : Vector, optional
            socket 'Position' (id: Position)

        direction : Vector, optional
            socket 'Direction' (id: Direction)

        length : Float, optional
            socket 'Length' (id: Length)

        only_local : bool
            parameter `only_local`


        Returns
        -------
        Float
            peer sockets: self_hit_ (Float), hit_distance_ (Float), hit_position_ (Vector), hit_normal_ (Vector)

        """
        node = Node('Raycast', {'Position': position, 'Direction': direction, 'Length': length}, only_local=only_local)
        return node._out

    @classmethod
    def script(cls,
                    bytecode = '',
                    bytecode_hash = '',
                    filepath = '',
                    mode: Literal['INTERNAL', 'EXTERNAL'] = 'INTERNAL',
                    script = None,
                    use_auto_update = False):
        """ > Node Script

        Parameters
        ----------
        bytecode : str
            parameter `bytecode`

        bytecode_hash : str
            parameter `bytecode_hash`

        filepath : str
            parameter `filepath`

        mode : Literal['Internal', 'External']
            parameter `mode`

        script : NoneType
            parameter `script`

        use_auto_update : bool
            parameter `use_auto_update`


        Returns
        -------
        None
        """
        utils.check_enum_arg('Script', 'mode', mode, 'script', ('INTERNAL', 'EXTERNAL'))
        node = Node('Script', bytecode=bytecode, bytecode_hash=bytecode_hash, filepath=filepath, mode=mode, script=script, use_auto_update=use_auto_update)
        return node._out

    @classmethod
    def separate_color(cls, color: Color = None, mode: Literal['RGB', 'HSV', 'HSL'] = 'RGB'):
        """ > Node Separate Color

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        mode : Literal['RGB', 'HSV', 'HSL']
            parameter `mode`


        Returns
        -------
        Float
            peer sockets: green_ (Float), blue_ (Float)

        """
        utils.check_enum_arg('Separate Color', 'mode', mode, 'separate_color', ('RGB', 'HSV', 'HSL'))
        node = Node('Separate Color', {'Color': color}, mode=mode)
        return node

    @classmethod
    def separate_xyz(cls, vector: Vector = None):
        """ > Node Separate XYZ

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)


        Returns
        -------
        Float
            peer sockets: y_ (Float), z_ (Float)

        """
        node = Node('Separate XYZ', {'Vector': vector})
        return node

    @classmethod
    def shader_to_rgb(cls, shader: Shader = None):
        """ > Node Shader to RGB

        Parameters
        ----------
        shader : Shader, optional
            socket 'Shader' (id: Shader)


        Returns
        -------
        Color
            peer sockets: alpha_ (Float)

        """
        node = Node('Shader to RGB', {'Shader': shader})
        return node._out

    @classmethod
    def subsurface_scattering(cls,
                    color: Color = None,
                    scale: Float = None,
                    radius: Vector = None,
                    ior: Float = None,
                    roughness: Float = None,
                    anisotropy: Float = None,
                    normal: Vector = None,
                    weight: Float = None,
                    falloff: Literal['BURLEY', 'RANDOM_WALK', 'RANDOM_WALK_SKIN'] = 'RANDOM_WALK'):
        """ > Node Subsurface Scattering

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        radius : Vector, optional
            socket 'Radius' (id: Radius)

        ior : Float, optional
            socket 'IOR' (id: IOR)

        roughness : Float, optional
            socket 'Roughness' (id: Roughness)

        anisotropy : Float, optional
            socket 'Anisotropy' (id: Anisotropy)

        normal : Vector, optional
            socket 'Normal' (id: Normal)

        weight : Float, optional
            socket 'Weight' (id: Weight)

        falloff : Literal['Christensen-Burley', 'Random Walk', 'Random Walk (Skin)']
            parameter `falloff`


        Returns
        -------
        Shader
        """
        utils.check_enum_arg('Subsurface Scattering', 'falloff', falloff, 'subsurface_scattering', ('BURLEY', 'RANDOM_WALK', 'RANDOM_WALK_SKIN'))
        node = Node('Subsurface Scattering', {'Color': color, 'Scale': scale, 'Radius': radius, 'IOR': ior, 'Roughness': roughness, 'Anisotropy': anisotropy, 'Normal': normal, 'Weight': weight}, falloff=falloff)
        return node._out

    @classmethod
    def tangent(cls,
                    axis: Literal['X', 'Y', 'Z'] = 'Z',
                    direction_type: Literal['RADIAL', 'UV_MAP'] = 'RADIAL',
                    uv_map = ''):
        """ > Node Tangent

        Parameters
        ----------
        axis : Literal['X', 'Y', 'Z']
            parameter `axis`

        direction_type : Literal['Radial', 'UV Map']
            parameter `direction_type`

        uv_map : str
            parameter `uv_map`


        Returns
        -------
        Vector
        """
        utils.check_enum_arg('Tangent', 'axis', axis, 'tangent', ('X', 'Y', 'Z'))
        utils.check_enum_arg('Tangent', 'direction_type', direction_type, 'tangent', ('RADIAL', 'UV_MAP'))
        node = Node('Tangent', axis=axis, direction_type=direction_type, uv_map=uv_map)
        return node._out

    @classmethod
    def brick_texture(cls,
                    vector: Vector = None,
                    color1: Color = None,
                    color2: Color = None,
                    mortar: Color = None,
                    scale: Float = None,
                    mortar_size: Float = None,
                    mortar_smooth: Float = None,
                    bias: Float = None,
                    brick_width: Float = None,
                    row_height: Float = None,
                    offset = 0.5,
                    offset_frequency = 2,
                    squash = 1.0,
                    squash_frequency = 2):
        """ > Node Brick Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        color1 : Color, optional
            socket 'Color1' (id: Color1)

        color2 : Color, optional
            socket 'Color2' (id: Color2)

        mortar : Color, optional
            socket 'Mortar' (id: Mortar)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        mortar_size : Float, optional
            socket 'Mortar Size' (id: Mortar Size)

        mortar_smooth : Float, optional
            socket 'Mortar Smooth' (id: Mortar Smooth)

        bias : Float, optional
            socket 'Bias' (id: Bias)

        brick_width : Float, optional
            socket 'Brick Width' (id: Brick Width)

        row_height : Float, optional
            socket 'Row Height' (id: Row Height)

        offset : float
            parameter `offset`

        offset_frequency : int
            parameter `offset_frequency`

        squash : float
            parameter `squash`

        squash_frequency : int
            parameter `squash_frequency`


        Returns
        -------
        Color
            peer sockets: factor_ (Float)

        """
        node = Node('Brick Texture', {'Vector': vector, 'Color1': color1, 'Color2': color2, 'Mortar': mortar, 'Scale': scale, 'Mortar Size': mortar_size, 'Mortar Smooth': mortar_smooth, 'Bias': bias, 'Brick Width': brick_width, 'Row Height': row_height}, offset=offset, offset_frequency=offset_frequency, squash=squash, squash_frequency=squash_frequency)
        return node._out

    @classmethod
    def checker_texture(cls,
                    vector: Vector = None,
                    color1: Color = None,
                    color2: Color = None,
                    scale: Float = None):
        """ > Node Checker Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        color1 : Color, optional
            socket 'Color1' (id: Color1)

        color2 : Color, optional
            socket 'Color2' (id: Color2)

        scale : Float, optional
            socket 'Scale' (id: Scale)


        Returns
        -------
        Color
            peer sockets: factor_ (Float)

        """
        node = Node('Checker Texture', {'Vector': vector, 'Color1': color1, 'Color2': color2, 'Scale': scale})
        return node._out

    @classmethod
    def texture_coordinate(cls, from_instancer = False, object = None):
        """ > Node Texture Coordinate

        Parameters
        ----------
        from_instancer : bool
            parameter `from_instancer`

        object : NoneType
            parameter `object`


        Returns
        -------
        Vector
            peer sockets: normal_ (Vector), uv_ (Vector), object_ (Vector), camera_ (Vector), window_ (Vector), reflection_ (Vector)

        """
        node = Node('Texture Coordinate', from_instancer=from_instancer, object=object)
        return node

    @classmethod
    def environment_texture(cls,
                    vector: Vector = None,
                    image = None,
                    interpolation: Literal['Linear', 'Closest', 'Cubic', 'Smart'] = 'Linear',
                    projection: Literal['EQUIRECTANGULAR', 'MIRROR_BALL'] = 'EQUIRECTANGULAR'):
        """ > Node Environment Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        image : NoneType
            parameter `image`

        interpolation : Literal['Linear', 'Closest', 'Cubic', 'Smart']
            parameter `interpolation`

        projection : Literal['Equirectangular', 'Mirror Ball']
            parameter `projection`


        Returns
        -------
        Color
        """
        utils.check_enum_arg('Environment Texture', 'interpolation', interpolation, 'environment_texture', ('Linear', 'Closest', 'Cubic', 'Smart'))
        utils.check_enum_arg('Environment Texture', 'projection', projection, 'environment_texture', ('EQUIRECTANGULAR', 'MIRROR_BALL'))
        node = Node('Environment Texture', {'Vector': vector}, image=image, interpolation=interpolation, projection=projection)
        return node._out

    @classmethod
    def gabor_texture(cls,
                    vector: Vector = None,
                    scale: Float = None,
                    frequency: Float = None,
                    anisotropy: Float = None,
                    orientation: Float = None,
                    orientation_1: Vector = None,
                    gabor_type: Literal['2D', '3D'] = '2D'):
        """ > Node Gabor Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        frequency : Float, optional
            socket 'Frequency' (id: Frequency)

        anisotropy : Float, optional
            socket 'Anisotropy' (id: Anisotropy)

        orientation : Float, optional
            socket 'Orientation' (id: Orientation 2D)

        orientation_1 : Vector, optional
            socket 'Orientation' (id: Orientation 3D)

        gabor_type : Literal['2D', '3D']
            parameter `gabor_type`


        Returns
        -------
        Float
            peer sockets: phase_ (Float), intensity_ (Float)

        """
        utils.check_enum_arg('Gabor Texture', 'gabor_type', gabor_type, 'gabor_texture', ('2D', '3D'))
        node = Node('Gabor Texture', {'Vector': vector, 'Scale': scale, 'Frequency': frequency, 'Anisotropy': anisotropy, 'Orientation 2D': orientation, 'Orientation 3D': orientation_1}, gabor_type=gabor_type)
        return node._out

    @classmethod
    def gradient_texture(cls,
                    vector: Vector = None,
                    gradient_type: Literal['LINEAR', 'QUADRATIC', 'EASING', 'DIAGONAL', 'SPHERICAL', 'QUADRATIC_SPHERE', 'RADIAL'] = 'LINEAR'):
        """ > Node Gradient Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        gradient_type : Literal['Linear', 'Quadratic', 'Easing', 'Diagonal', 'Spherical', 'Quadratic Sphere', 'Radial']
            parameter `gradient_type`


        Returns
        -------
        Color
            peer sockets: factor_ (Float)

        """
        utils.check_enum_arg('Gradient Texture', 'gradient_type', gradient_type, 'gradient_texture', ('LINEAR', 'QUADRATIC', 'EASING', 'DIAGONAL', 'SPHERICAL', 'QUADRATIC_SPHERE', 'RADIAL'))
        node = Node('Gradient Texture', {'Vector': vector}, gradient_type=gradient_type)
        return node._out

    @classmethod
    def ies_texture(cls,
                    vector: Vector = None,
                    strength: Float = None,
                    filepath = '',
                    ies = None,
                    mode: Literal['INTERNAL', 'EXTERNAL'] = 'INTERNAL'):
        """ > Node IES Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        strength : Float, optional
            socket 'Strength' (id: Strength)

        filepath : str
            parameter `filepath`

        ies : NoneType
            parameter `ies`

        mode : Literal['Internal', 'External']
            parameter `mode`


        Returns
        -------
        Float
        """
        utils.check_enum_arg('IES Texture', 'mode', mode, 'ies_texture', ('INTERNAL', 'EXTERNAL'))
        node = Node('IES Texture', {'Vector': vector, 'Strength': strength}, filepath=filepath, ies=ies, mode=mode)
        return node._out

    @classmethod
    def image_texture(cls,
                    vector: Vector = None,
                    extension: Literal['REPEAT', 'EXTEND', 'CLIP', 'MIRROR'] = 'REPEAT',
                    image = None,
                    interpolation: Literal['Linear', 'Closest', 'Cubic', 'Smart'] = 'Linear',
                    projection: Literal['FLAT', 'BOX', 'SPHERE', 'TUBE'] = 'FLAT',
                    projection_blend = 0.0):
        """ > Node Image Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        extension : Literal['Repeat', 'Extend', 'Clip', 'Mirror']
            parameter `extension`

        image : NoneType
            parameter `image`

        interpolation : Literal['Linear', 'Closest', 'Cubic', 'Smart']
            parameter `interpolation`

        projection : Literal['Flat', 'Box', 'Sphere', 'Tube']
            parameter `projection`

        projection_blend : float
            parameter `projection_blend`


        Returns
        -------
        Color
            peer sockets: alpha_ (Float)

        """
        utils.check_enum_arg('Image Texture', 'extension', extension, 'image_texture', ('REPEAT', 'EXTEND', 'CLIP', 'MIRROR'))
        utils.check_enum_arg('Image Texture', 'interpolation', interpolation, 'image_texture', ('Linear', 'Closest', 'Cubic', 'Smart'))
        utils.check_enum_arg('Image Texture', 'projection', projection, 'image_texture', ('FLAT', 'BOX', 'SPHERE', 'TUBE'))
        node = Node('Image Texture', {'Vector': vector}, extension=extension, image=image, interpolation=interpolation, projection=projection, projection_blend=projection_blend)
        return node._out

    @classmethod
    def magic_texture(cls,
                    vector: Vector = None,
                    scale: Float = None,
                    distortion: Float = None,
                    turbulence_depth = 2):
        """ > Node Magic Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        distortion : Float, optional
            socket 'Distortion' (id: Distortion)

        turbulence_depth : int
            parameter `turbulence_depth`


        Returns
        -------
        Color
            peer sockets: factor_ (Float)

        """
        node = Node('Magic Texture', {'Vector': vector, 'Scale': scale, 'Distortion': distortion}, turbulence_depth=turbulence_depth)
        return node._out

    @classmethod
    def noise_texture(cls,
                    vector: Vector = None,
                    w: Float = None,
                    scale: Float = None,
                    detail: Float = None,
                    roughness: Float = None,
                    lacunarity: Float = None,
                    offset: Float = None,
                    gain: Float = None,
                    distortion: Float = None,
                    noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D',
                    noise_type: Literal['MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN'] = 'FBM',
                    normalize = True):
        """ > Node Noise Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        w : Float, optional
            socket 'W' (id: W)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        detail : Float, optional
            socket 'Detail' (id: Detail)

        roughness : Float, optional
            socket 'Roughness' (id: Roughness)

        lacunarity : Float, optional
            socket 'Lacunarity' (id: Lacunarity)

        offset : Float, optional
            socket 'Offset' (id: Offset)

        gain : Float, optional
            socket 'Gain' (id: Gain)

        distortion : Float, optional
            socket 'Distortion' (id: Distortion)

        noise_dimensions : Literal['1D', '2D', '3D', '4D']
            parameter `noise_dimensions`

        noise_type : Literal['Multifractal', 'Ridged Multifractal', 'Hybrid Multifractal', 'fBM', 'Hetero Terrain']
            parameter `noise_type`

        normalize : bool
            parameter `normalize`


        Returns
        -------
        Float
            peer sockets: color_ (Color)

        """
        utils.check_enum_arg('Noise Texture', 'noise_dimensions', noise_dimensions, 'noise_texture', ('1D', '2D', '3D', '4D'))
        utils.check_enum_arg('Noise Texture', 'noise_type', noise_type, 'noise_texture', ('MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN'))
        node = Node('Noise Texture', {'Vector': vector, 'W': w, 'Scale': scale, 'Detail': detail, 'Roughness': roughness, 'Lacunarity': lacunarity, 'Offset': offset, 'Gain': gain, 'Distortion': distortion}, noise_dimensions=noise_dimensions, noise_type=noise_type, normalize=normalize)
        return node._out

    @classmethod
    def sky_texture(cls,
                    vector: Vector = None,
                    aerosol_density = 1.0,
                    air_density = 1.0,
                    altitude = 100.0,
                    ground_albedo = 0.30000001192092896,
                    ozone_density = 1.0,
                    sky_type: Literal['SINGLE_SCATTERING', 'MULTIPLE_SCATTERING', 'PREETHAM', 'HOSEK_WILKIE'] = 'MULTIPLE_SCATTERING',
                    sun_disc = True,
                    sun_elevation = 0.2617993950843811,
                    sun_intensity = 1.0,
                    sun_rotation = 0.0,
                    sun_size = 0.009512044489383698,
                    turbidity = 2.200000047683716):
        """ > Node Sky Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        aerosol_density : float
            parameter `aerosol_density`

        air_density : float
            parameter `air_density`

        altitude : float
            parameter `altitude`

        ground_albedo : float
            parameter `ground_albedo`

        ozone_density : float
            parameter `ozone_density`

        sky_type : Literal['Single Scattering', 'Multiple Scattering', 'Preetham', 'Hosek / Wilkie']
            parameter `sky_type`

        sun_disc : bool
            parameter `sun_disc`

        sun_elevation : float
            parameter `sun_elevation`

        sun_intensity : float
            parameter `sun_intensity`

        sun_rotation : float
            parameter `sun_rotation`

        sun_size : float
            parameter `sun_size`

        turbidity : float
            parameter `turbidity`


        Returns
        -------
        Color
        """
        utils.check_enum_arg('Sky Texture', 'sky_type', sky_type, 'sky_texture', ('SINGLE_SCATTERING', 'MULTIPLE_SCATTERING', 'PREETHAM', 'HOSEK_WILKIE'))
        node = Node('Sky Texture', {'Vector': vector}, aerosol_density=aerosol_density, air_density=air_density, altitude=altitude, ground_albedo=ground_albedo, ozone_density=ozone_density, sky_type=sky_type, sun_disc=sun_disc, sun_elevation=sun_elevation, sun_intensity=sun_intensity, sun_rotation=sun_rotation, sun_size=sun_size, turbidity=turbidity)
        return node._out

    @classmethod
    def voronoi_texture(cls,
                    vector: Vector = None,
                    w: Float = None,
                    scale: Float = None,
                    detail: Float = None,
                    roughness: Float = None,
                    lacunarity: Float = None,
                    smoothness: Float = None,
                    exponent: Float = None,
                    randomness: Float = None,
                    distance: Literal['EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'] = 'EUCLIDEAN',
                    feature: Literal['F1', 'F2', 'SMOOTH_F1', 'DISTANCE_TO_EDGE', 'N_SPHERE_RADIUS'] = 'F1',
                    normalize = False,
                    voronoi_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D'):
        """ > Node Voronoi Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        w : Float, optional
            socket 'W' (id: W)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        detail : Float, optional
            socket 'Detail' (id: Detail)

        roughness : Float, optional
            socket 'Roughness' (id: Roughness)

        lacunarity : Float, optional
            socket 'Lacunarity' (id: Lacunarity)

        smoothness : Float, optional
            socket 'Smoothness' (id: Smoothness)

        exponent : Float, optional
            socket 'Exponent' (id: Exponent)

        randomness : Float, optional
            socket 'Randomness' (id: Randomness)

        distance : Literal['Euclidean', 'Manhattan', 'Chebychev', 'Minkowski']
            parameter `distance`

        feature : Literal['F1', 'F2', 'Smooth F1', 'Distance to Edge', 'N-Sphere Radius']
            parameter `feature`

        normalize : bool
            parameter `normalize`

        voronoi_dimensions : Literal['1D', '2D', '3D', '4D']
            parameter `voronoi_dimensions`


        Returns
        -------
        Float
            peer sockets: color_ (Color), position_ (Vector)

        """
        utils.check_enum_arg('Voronoi Texture', 'distance', distance, 'voronoi_texture', ('EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'))
        utils.check_enum_arg('Voronoi Texture', 'feature', feature, 'voronoi_texture', ('F1', 'F2', 'SMOOTH_F1', 'DISTANCE_TO_EDGE', 'N_SPHERE_RADIUS'))
        utils.check_enum_arg('Voronoi Texture', 'voronoi_dimensions', voronoi_dimensions, 'voronoi_texture', ('1D', '2D', '3D', '4D'))
        node = Node('Voronoi Texture', {'Vector': vector, 'W': w, 'Scale': scale, 'Detail': detail, 'Roughness': roughness, 'Lacunarity': lacunarity, 'Smoothness': smoothness, 'Exponent': exponent, 'Randomness': randomness}, distance=distance, feature=feature, normalize=normalize, voronoi_dimensions=voronoi_dimensions)
        return node._out

    @classmethod
    def wave_texture(cls,
                    vector: Vector = None,
                    scale: Float = None,
                    distortion: Float = None,
                    detail: Float = None,
                    detail_scale: Float = None,
                    detail_roughness: Float = None,
                    phase_offset: Float = None,
                    bands_direction: Literal['X', 'Y', 'Z', 'DIAGONAL'] = 'X',
                    rings_direction: Literal['X', 'Y', 'Z', 'SPHERICAL'] = 'X',
                    wave_profile: Literal['SIN', 'SAW', 'TRI'] = 'SIN',
                    wave_type: Literal['BANDS', 'RINGS'] = 'BANDS'):
        """ > Node Wave Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        distortion : Float, optional
            socket 'Distortion' (id: Distortion)

        detail : Float, optional
            socket 'Detail' (id: Detail)

        detail_scale : Float, optional
            socket 'Detail Scale' (id: Detail Scale)

        detail_roughness : Float, optional
            socket 'Detail Roughness' (id: Detail Roughness)

        phase_offset : Float, optional
            socket 'Phase Offset' (id: Phase Offset)

        bands_direction : Literal['X', 'Y', 'Z', 'Diagonal']
            parameter `bands_direction`

        rings_direction : Literal['X', 'Y', 'Z', 'Spherical']
            parameter `rings_direction`

        wave_profile : Literal['Sine', 'Saw', 'Triangle']
            parameter `wave_profile`

        wave_type : Literal['Bands', 'Rings']
            parameter `wave_type`


        Returns
        -------
        Color
            peer sockets: factor_ (Float)

        """
        utils.check_enum_arg('Wave Texture', 'bands_direction', bands_direction, 'wave_texture', ('X', 'Y', 'Z', 'DIAGONAL'))
        utils.check_enum_arg('Wave Texture', 'rings_direction', rings_direction, 'wave_texture', ('X', 'Y', 'Z', 'SPHERICAL'))
        utils.check_enum_arg('Wave Texture', 'wave_profile', wave_profile, 'wave_texture', ('SIN', 'SAW', 'TRI'))
        utils.check_enum_arg('Wave Texture', 'wave_type', wave_type, 'wave_texture', ('BANDS', 'RINGS'))
        node = Node('Wave Texture', {'Vector': vector, 'Scale': scale, 'Distortion': distortion, 'Detail': detail, 'Detail Scale': detail_scale, 'Detail Roughness': detail_roughness, 'Phase Offset': phase_offset}, bands_direction=bands_direction, rings_direction=rings_direction, wave_profile=wave_profile, wave_type=wave_type)
        return node._out

    @classmethod
    def white_noise_texture(cls,
                    vector: Vector = None,
                    w: Float = None,
                    noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D'):
        """ > Node White Noise Texture

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        w : Float, optional
            socket 'W' (id: W)

        noise_dimensions : Literal['1D', '2D', '3D', '4D']
            parameter `noise_dimensions`


        Returns
        -------
        Float
            peer sockets: color_ (Color)

        """
        utils.check_enum_arg('White Noise Texture', 'noise_dimensions', noise_dimensions, 'white_noise_texture', ('1D', '2D', '3D', '4D'))
        node = Node('White Noise Texture', {'Vector': vector, 'W': w}, noise_dimensions=noise_dimensions)
        return node._out

    @classmethod
    def uv_along_stroke(cls, use_tips = False):
        """ > Node UV Along Stroke

        Parameters
        ----------
        use_tips : bool
            parameter `use_tips`


        Returns
        -------
        Vector
        """
        node = Node('UV Along Stroke', use_tips=use_tips)
        return node._out

    @classmethod
    def uv_map(cls, from_instancer = False, uv_map = ''):
        """ > Node UV Map

        Parameters
        ----------
        from_instancer : bool
            parameter `from_instancer`

        uv_map : str
            parameter `uv_map`


        Returns
        -------
        Vector
        """
        node = Node('UV Map', from_instancer=from_instancer, uv_map=uv_map)
        return node._out

    @classmethod
    def color_ramp(cls, fac=None, stops=None, interpolation='LINEAR'):
        """ Node Color Ramp

        Exposes utilities to manage the color ramp

        ``` python
        ramp1 = Float(.5).color_ramp(stops=[.1, .9])
        ramp2 = ColorRamp(.5, stops=[(.1, (1, 0, 0)), (.5, 1), (.9, (0, 0, 1))])
        ```

        Parameters
        ----------
        fac : Float, optional

        stops : list[tuple[float, tuple]]
            Stops made of (float, color as tuple of floats)

        interpolation : {'EASE', 'CARDINAL', 'LINEAR', 'B_SPLINE', 'CONSTANT'}

        """
        node = ColorRamp(fac=fac, stops=stops, interpolation=interpolation)
        return node._out

    @utils.classproperty
    def value(self):
        """ > Node Value

        Returns
        -------
        Float
        """
        node = Node('Value', )
        return node._out

    @classmethod
    def vector_curves(cls, vector: Vector = None, factor: Float = None):
        """ > Node Vector Curves

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        factor : Float, optional
            socket 'Factor' (id: Fac)


        Returns
        -------
        Vector
        """
        node = NodeCurves('Vector Curves', {'Vector': vector, 'Fac': factor})
        return node._out

    @classmethod
    def vector_displacement(cls,
                    vector: Color = None,
                    midlevel: Float = None,
                    scale: Float = None,
                    space: Literal['TANGENT', 'OBJECT', 'WORLD'] = 'TANGENT'):
        """ > Node Vector Displacement

        Parameters
        ----------
        vector : Color, optional
            socket 'Vector' (id: Vector)

        midlevel : Float, optional
            socket 'Midlevel' (id: Midlevel)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        space : Literal['Tangent Space', 'Object Space', 'World Space']
            parameter `space`


        Returns
        -------
        Vector
        """
        utils.check_enum_arg('Vector Displacement', 'space', space, 'vector_displacement', ('TANGENT', 'OBJECT', 'WORLD'))
        node = Node('Vector Displacement', {'Vector': vector, 'Midlevel': midlevel, 'Scale': scale}, space=space)
        return node._out

    @classmethod
    def vector_math(cls,
                    vector: Vector = None,
                    vector_1: Vector = None,
                    vector_2: Vector = None,
                    scale: Float = None,
                    operation: Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'CROSS_PRODUCT', 'PROJECT', 'REFLECT', 'REFRACT', 'FACEFORWARD', 'DOT_PRODUCT', 'DISTANCE', 'LENGTH', 'SCALE', 'NORMALIZE', 'ABSOLUTE', 'POWER', 'SIGN', 'MINIMUM', 'MAXIMUM', 'ROUND', 'FLOOR', 'CEIL', 'FRACTION', 'MODULO', 'WRAP', 'SNAP', 'SINE', 'COSINE', 'TANGENT'] = 'ADD'):
        """ > Node Vector Math

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        vector_1 : Vector, optional
            socket 'Vector' (id: Vector_001)

        vector_2 : Vector, optional
            socket 'Vector' (id: Vector_002)

        scale : Float, optional
            socket 'Scale' (id: Scale)

        operation : Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Cross Product', 'Project', 'Reflect', 'Refract', 'Faceforward', 'Dot Product', 'Distance', 'Length', 'Scale', 'Normalize', 'Absolute', 'Power', 'Sign', 'Minimum', 'Maximum', 'Round', 'Floor', 'Ceil', 'Fraction', 'Modulo', 'Wrap', 'Snap', 'Sine', 'Cosine', 'Tangent']
            parameter `operation`


        Returns
        -------
        Vector
        """
        utils.check_enum_arg('Vector Math', 'operation', operation, 'vector_math', ('ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'CROSS_PRODUCT', 'PROJECT', 'REFLECT', 'REFRACT', 'FACEFORWARD', 'DOT_PRODUCT', 'DISTANCE', 'LENGTH', 'SCALE', 'NORMALIZE', 'ABSOLUTE', 'POWER', 'SIGN', 'MINIMUM', 'MAXIMUM', 'ROUND', 'FLOOR', 'CEIL', 'FRACTION', 'MODULO', 'WRAP', 'SNAP', 'SINE', 'COSINE', 'TANGENT'))
        node = Node('Vector Math', {'Vector': vector, 'Vector_001': vector_1, 'Vector_002': vector_2, 'Scale': scale}, operation=operation)
        return node._out

    @classmethod
    def vector_rotate(cls,
                    vector: Vector = None,
                    center: Vector = None,
                    axis: Vector = None,
                    angle: Float = None,
                    rotation: Vector = None,
                    invert = False,
                    rotation_type: Literal['AXIS_ANGLE', 'X_AXIS', 'Y_AXIS', 'Z_AXIS', 'EULER_XYZ'] = 'AXIS_ANGLE'):
        """ > Node Vector Rotate

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        center : Vector, optional
            socket 'Center' (id: Center)

        axis : Vector, optional
            socket 'Axis' (id: Axis)

        angle : Float, optional
            socket 'Angle' (id: Angle)

        rotation : Vector, optional
            socket 'Rotation' (id: Rotation)

        invert : bool
            parameter `invert`

        rotation_type : Literal['Axis Angle', 'X Axis', 'Y Axis', 'Z Axis', 'Euler']
            parameter `rotation_type`


        Returns
        -------
        Vector
        """
        utils.check_enum_arg('Vector Rotate', 'rotation_type', rotation_type, 'vector_rotate', ('AXIS_ANGLE', 'X_AXIS', 'Y_AXIS', 'Z_AXIS', 'EULER_XYZ'))
        node = Node('Vector Rotate', {'Vector': vector, 'Center': center, 'Axis': axis, 'Angle': angle, 'Rotation': rotation}, invert=invert, rotation_type=rotation_type)
        return node._out

    @classmethod
    def vector_transform(cls,
                    vector: Vector = None,
                    convert_from: Literal['WORLD', 'OBJECT', 'CAMERA'] = 'WORLD',
                    convert_to: Literal['WORLD', 'OBJECT', 'CAMERA'] = 'OBJECT',
                    vector_type: Literal['POINT', 'VECTOR', 'NORMAL'] = 'VECTOR'):
        """ > Node Vector Transform

        Parameters
        ----------
        vector : Vector, optional
            socket 'Vector' (id: Vector)

        convert_from : Literal['World', 'Object', 'Camera']
            parameter `convert_from`

        convert_to : Literal['World', 'Object', 'Camera']
            parameter `convert_to`

        vector_type : Literal['Point', 'Vector', 'Normal']
            parameter `vector_type`


        Returns
        -------
        Vector
        """
        utils.check_enum_arg('Vector Transform', 'convert_from', convert_from, 'vector_transform', ('WORLD', 'OBJECT', 'CAMERA'))
        utils.check_enum_arg('Vector Transform', 'convert_to', convert_to, 'vector_transform', ('WORLD', 'OBJECT', 'CAMERA'))
        utils.check_enum_arg('Vector Transform', 'vector_type', vector_type, 'vector_transform', ('POINT', 'VECTOR', 'NORMAL'))
        node = Node('Vector Transform', {'Vector': vector}, convert_from=convert_from, convert_to=convert_to, vector_type=vector_type)
        return node._out

    @classmethod
    def color_attribute(cls, layer_name = ''):
        """ > Node Color Attribute

        Parameters
        ----------
        layer_name : str
            parameter `layer_name`


        Returns
        -------
        Color
            peer sockets: alpha_ (Float)

        """
        node = Node('Color Attribute', layer_name=layer_name)
        return node

    @classmethod
    def volume_absorption(cls, color: Color = None, density: Float = None, weight: Float = None):
        """ > Node Volume Absorption

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        density : Float, optional
            socket 'Density' (id: Density)

        weight : Float, optional
            socket 'Weight' (id: Weight)


        Returns
        -------
        VolumeShader
        """
        node = Node('Volume Absorption', {'Color': color, 'Density': density, 'Weight': weight})
        return node._out

    @classmethod
    def volume_coefficients(cls,
                    weight: Float = None,
                    absorption_coefficients: Vector = None,
                    scatter_coefficients: Vector = None,
                    anisotropy: Float = None,
                    ior: Float = None,
                    backscatter: Float = None,
                    alpha: Float = None,
                    diameter: Float = None,
                    emission_coefficients: Vector = None,
                    phase: Literal['HENYEY_GREENSTEIN', 'FOURNIER_FORAND', 'DRAINE', 'RAYLEIGH', 'MIE'] = 'HENYEY_GREENSTEIN'):
        """ > Node Volume Coefficients

        Parameters
        ----------
        weight : Float, optional
            socket 'Weight' (id: Weight)

        absorption_coefficients : Vector, optional
            socket 'Absorption Coefficients' (id: Absorption Coefficients)

        scatter_coefficients : Vector, optional
            socket 'Scatter Coefficients' (id: Scatter Coefficients)

        anisotropy : Float, optional
            socket 'Anisotropy' (id: Anisotropy)

        ior : Float, optional
            socket 'IOR' (id: IOR)

        backscatter : Float, optional
            socket 'Backscatter' (id: Backscatter)

        alpha : Float, optional
            socket 'Alpha' (id: Alpha)

        diameter : Float, optional
            socket 'Diameter' (id: Diameter)

        emission_coefficients : Vector, optional
            socket 'Emission Coefficients' (id: Emission Coefficients)

        phase : Literal['Henyey-Greenstein', 'Fournier-Forand', 'Draine', 'Rayleigh', 'Mie']
            parameter `phase`


        Returns
        -------
        VolumeShader
        """
        utils.check_enum_arg('Volume Coefficients', 'phase', phase, 'volume_coefficients', ('HENYEY_GREENSTEIN', 'FOURNIER_FORAND', 'DRAINE', 'RAYLEIGH', 'MIE'))
        node = Node('Volume Coefficients', {'Weight': weight, 'Absorption Coefficients': absorption_coefficients, 'Scatter Coefficients': scatter_coefficients, 'Anisotropy': anisotropy, 'IOR': ior, 'Backscatter': backscatter, 'Alpha': alpha, 'Diameter': diameter, 'Emission Coefficients': emission_coefficients}, phase=phase)
        return node._out

    @classmethod
    def volume_info(cls):
        """ > Node Volume Info

        Returns
        -------
        Color
            peer sockets: density_ (Float), flame_ (Float), temperature_ (Float)

        """
        node = Node('Volume Info', )
        return node

    @classmethod
    def principled_volume(cls,
                    color: Color = None,
                    color_attribute: String = None,
                    density: Float = None,
                    density_attribute: String = None,
                    anisotropy: Float = None,
                    absorption_color: Color = None,
                    emission_strength: Float = None,
                    emission_color: Color = None,
                    blackbody_intensity: Float = None,
                    blackbody_tint: Color = None,
                    temperature: Float = None,
                    temperature_attribute: String = None,
                    weight: Float = None):
        """ > Node Principled Volume

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        color_attribute : String, optional
            socket 'Color Attribute' (id: Color Attribute)

        density : Float, optional
            socket 'Density' (id: Density)

        density_attribute : String, optional
            socket 'Density Attribute' (id: Density Attribute)

        anisotropy : Float, optional
            socket 'Anisotropy' (id: Anisotropy)

        absorption_color : Color, optional
            socket 'Absorption Color' (id: Absorption Color)

        emission_strength : Float, optional
            socket 'Emission Strength' (id: Emission Strength)

        emission_color : Color, optional
            socket 'Emission Color' (id: Emission Color)

        blackbody_intensity : Float, optional
            socket 'Blackbody Intensity' (id: Blackbody Intensity)

        blackbody_tint : Color, optional
            socket 'Blackbody Tint' (id: Blackbody Tint)

        temperature : Float, optional
            socket 'Temperature' (id: Temperature)

        temperature_attribute : String, optional
            socket 'Temperature Attribute' (id: Temperature Attribute)

        weight : Float, optional
            socket 'Weight' (id: Weight)


        Returns
        -------
        VolumeShader
        """
        node = Node('Principled Volume', {'Color': color, 'Color Attribute': color_attribute, 'Density': density, 'Density Attribute': density_attribute, 'Anisotropy': anisotropy, 'Absorption Color': absorption_color, 'Emission Strength': emission_strength, 'Emission Color': emission_color, 'Blackbody Intensity': blackbody_intensity, 'Blackbody Tint': blackbody_tint, 'Temperature': temperature, 'Temperature Attribute': temperature_attribute, 'Weight': weight})
        return node._out

    @classmethod
    def volume_scatter(cls,
                    color: Color = None,
                    density: Float = None,
                    anisotropy: Float = None,
                    ior: Float = None,
                    backscatter: Float = None,
                    alpha: Float = None,
                    diameter: Float = None,
                    weight: Float = None,
                    phase: Literal['HENYEY_GREENSTEIN', 'FOURNIER_FORAND', 'DRAINE', 'RAYLEIGH', 'MIE'] = 'HENYEY_GREENSTEIN'):
        """ > Node Volume Scatter

        Parameters
        ----------
        color : Color, optional
            socket 'Color' (id: Color)

        density : Float, optional
            socket 'Density' (id: Density)

        anisotropy : Float, optional
            socket 'Anisotropy' (id: Anisotropy)

        ior : Float, optional
            socket 'IOR' (id: IOR)

        backscatter : Float, optional
            socket 'Backscatter' (id: Backscatter)

        alpha : Float, optional
            socket 'Alpha' (id: Alpha)

        diameter : Float, optional
            socket 'Diameter' (id: Diameter)

        weight : Float, optional
            socket 'Weight' (id: Weight)

        phase : Literal['Henyey-Greenstein', 'Fournier-Forand', 'Draine', 'Rayleigh', 'Mie']
            parameter `phase`


        Returns
        -------
        VolumeShader
        """
        utils.check_enum_arg('Volume Scatter', 'phase', phase, 'volume_scatter', ('HENYEY_GREENSTEIN', 'FOURNIER_FORAND', 'DRAINE', 'RAYLEIGH', 'MIE'))
        node = Node('Volume Scatter', {'Color': color, 'Density': density, 'Anisotropy': anisotropy, 'IOR': ior, 'Backscatter': backscatter, 'Alpha': alpha, 'Diameter': diameter, 'Weight': weight}, phase=phase)
        return node._out

    @classmethod
    def wavelength(cls, wavelength: Float = None):
        """ > Node Wavelength

        Parameters
        ----------
        wavelength : Float, optional
            socket 'Wavelength' (id: Wavelength)


        Returns
        -------
        Color
        """
        node = Node('Wavelength', {'Wavelength': wavelength})
        return node._out

    @classmethod
    def wireframe(cls, size: Float = None, use_pixel_size = False):
        """ > Node Wireframe

        Parameters
        ----------
        size : Float, optional
            socket 'Size' (id: Size)

        use_pixel_size : bool
            parameter `use_pixel_size`


        Returns
        -------
        Float
        """
        node = Node('Wireframe', {'Size': size}, use_pixel_size=use_pixel_size)
        return node._out

add_shader(shader=None, shader_1=None) classmethod

Node Add Shader

Parameters:

Name	Type	Description	Default
shader	Shader	socket 'Shader' (id: Shader)	None
shader_1	Shader	socket 'Shader' (id: Shader_001)	None

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def add_shader(cls, shader: Shader = None, shader_1: Shader = None):
    """ > Node Add Shader

    Parameters
    ----------
    shader : Shader, optional
        socket 'Shader' (id: Shader)

    shader_1 : Shader, optional
        socket 'Shader' (id: Shader_001)


    Returns
    -------
    Shader
    """
    node = Node('Add Shader', {'Shader': shader, 'Shader_001': shader_1})
    return node._out

ambient_occlusion(color=None, distance=None, normal=None, inside=False, only_local=False, samples=16) classmethod

Node Ambient Occlusion

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
distance	Float	socket 'Distance' (id: Distance)	None
normal	Vector	socket 'Normal' (id: Normal)	None
inside	bool	parameter inside	False
only_local	bool	parameter only_local	False
samples	int	parameter samples	16

Returns:

Type	Description
Color	peer sockets: ao_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def ambient_occlusion(cls,
                color: Color = None,
                distance: Float = None,
                normal: Vector = None,
                inside = False,
                only_local = False,
                samples = 16):
    """ > Node Ambient Occlusion

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    distance : Float, optional
        socket 'Distance' (id: Distance)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    inside : bool
        parameter `inside`

    only_local : bool
        parameter `only_local`

    samples : int
        parameter `samples`


    Returns
    -------
    Color
        peer sockets: ao_ (Float)

    """
    node = Node('Ambient Occlusion', {'Color': color, 'Distance': distance, 'Normal': normal}, inside=inside, only_local=only_local, samples=samples)
    return node._out

aov_output(color=None, value=None, aov_name='') classmethod

Node AOV Output

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
value	Float	socket 'Value' (id: Value)	None
aov_name	str	parameter aov_name	''

Returns:

Type	Description
None

Source code in core/generated/static_snd.py

@classmethod
def aov_output(cls, color: Color = None, value: Float = None, aov_name = ''):
    """ > Node AOV Output

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    value : Float, optional
        socket 'Value' (id: Value)

    aov_name : str
        parameter `aov_name`


    Returns
    -------
    None
    """
    node = Node('AOV Output', {'Color': color, 'Value': value}, aov_name=aov_name)
    return node._out

attribute(attribute_name='', attribute_type='GEOMETRY') classmethod

Node Attribute

Parameters:

Name	Type	Description	Default
attribute_name	str	parameter attribute_name	''
attribute_type	Literal['Geometry', 'Object', 'Instancer', 'View Layer']	parameter attribute_type	'GEOMETRY'

Returns:

Type	Description
Color	peer sockets: vector_ (Vector), factor_ (Float), alpha_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def attribute(cls,
                attribute_name = '',
                attribute_type: Literal['GEOMETRY', 'OBJECT', 'INSTANCER', 'VIEW_LAYER'] = 'GEOMETRY'):
    """ > Node Attribute

    Parameters
    ----------
    attribute_name : str
        parameter `attribute_name`

    attribute_type : Literal['Geometry', 'Object', 'Instancer', 'View Layer']
        parameter `attribute_type`


    Returns
    -------
    Color
        peer sockets: vector_ (Vector), factor_ (Float), alpha_ (Float)

    """
    utils.check_enum_arg('Attribute', 'attribute_type', attribute_type, 'attribute', ('GEOMETRY', 'OBJECT', 'INSTANCER', 'VIEW_LAYER'))
    node = Node('Attribute', attribute_name=attribute_name, attribute_type=attribute_type)
    return node

background(color=None, strength=None, weight=None) classmethod

Node Background

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
strength	Float	socket 'Strength' (id: Strength)	None
weight	Float	socket 'Weight' (id: Weight)	None

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def background(cls, color: Color = None, strength: Float = None, weight: Float = None):
    """ > Node Background

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    strength : Float, optional
        socket 'Strength' (id: Strength)

    weight : Float, optional
        socket 'Weight' (id: Weight)


    Returns
    -------
    Shader
    """
    node = Node('Background', {'Color': color, 'Strength': strength, 'Weight': weight})
    return node._out

bevel(radius=None, normal=None, samples=4) classmethod

Node Bevel

Parameters:

Name	Type	Description	Default
radius	Float	socket 'Radius' (id: Radius)	None
normal	Vector	socket 'Normal' (id: Normal)	None
samples	int	parameter samples	4

Returns:

Type	Description
Vector

Source code in core/generated/static_snd.py

@classmethod
def bevel(cls, radius: Float = None, normal: Vector = None, samples = 4):
    """ > Node Bevel

    Parameters
    ----------
    radius : Float, optional
        socket 'Radius' (id: Radius)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    samples : int
        parameter `samples`


    Returns
    -------
    Vector
    """
    node = Node('Bevel', {'Radius': radius, 'Normal': normal}, samples=samples)
    return node._out

blackbody(temperature=None) classmethod

Node Blackbody

Parameters:

Name	Type	Description	Default
temperature	Float	socket 'Temperature' (id: Temperature)	None

Returns:

Type	Description
Color

Source code in core/generated/static_snd.py

@classmethod
def blackbody(cls, temperature: Float = None):
    """ > Node Blackbody

    Parameters
    ----------
    temperature : Float, optional
        socket 'Temperature' (id: Temperature)


    Returns
    -------
    Color
    """
    node = Node('Blackbody', {'Temperature': temperature})
    return node._out

brick_texture(vector=None, color1=None, color2=None, mortar=None, scale=None, mortar_size=None, mortar_smooth=None, bias=None, brick_width=None, row_height=None, offset=0.5, offset_frequency=2, squash=1.0, squash_frequency=2) classmethod

Node Brick Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
color1	Color	socket 'Color1' (id: Color1)	None
color2	Color	socket 'Color2' (id: Color2)	None
mortar	Color	socket 'Mortar' (id: Mortar)	None
scale	Float	socket 'Scale' (id: Scale)	None
mortar_size	Float	socket 'Mortar Size' (id: Mortar Size)	None
mortar_smooth	Float	socket 'Mortar Smooth' (id: Mortar Smooth)	None
bias	Float	socket 'Bias' (id: Bias)	None
brick_width	Float	socket 'Brick Width' (id: Brick Width)	None
row_height	Float	socket 'Row Height' (id: Row Height)	None
offset	float	parameter offset	0.5
offset_frequency	int	parameter offset_frequency	2
squash	float	parameter squash	1.0
squash_frequency	int	parameter squash_frequency	2

Returns:

Type	Description
Color	peer sockets: factor_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def brick_texture(cls,
                vector: Vector = None,
                color1: Color = None,
                color2: Color = None,
                mortar: Color = None,
                scale: Float = None,
                mortar_size: Float = None,
                mortar_smooth: Float = None,
                bias: Float = None,
                brick_width: Float = None,
                row_height: Float = None,
                offset = 0.5,
                offset_frequency = 2,
                squash = 1.0,
                squash_frequency = 2):
    """ > Node Brick Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    color1 : Color, optional
        socket 'Color1' (id: Color1)

    color2 : Color, optional
        socket 'Color2' (id: Color2)

    mortar : Color, optional
        socket 'Mortar' (id: Mortar)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    mortar_size : Float, optional
        socket 'Mortar Size' (id: Mortar Size)

    mortar_smooth : Float, optional
        socket 'Mortar Smooth' (id: Mortar Smooth)

    bias : Float, optional
        socket 'Bias' (id: Bias)

    brick_width : Float, optional
        socket 'Brick Width' (id: Brick Width)

    row_height : Float, optional
        socket 'Row Height' (id: Row Height)

    offset : float
        parameter `offset`

    offset_frequency : int
        parameter `offset_frequency`

    squash : float
        parameter `squash`

    squash_frequency : int
        parameter `squash_frequency`


    Returns
    -------
    Color
        peer sockets: factor_ (Float)

    """
    node = Node('Brick Texture', {'Vector': vector, 'Color1': color1, 'Color2': color2, 'Mortar': mortar, 'Scale': scale, 'Mortar Size': mortar_size, 'Mortar Smooth': mortar_smooth, 'Bias': bias, 'Brick Width': brick_width, 'Row Height': row_height}, offset=offset, offset_frequency=offset_frequency, squash=squash, squash_frequency=squash_frequency)
    return node._out

brightness_contrast(color=None, brightness=None, contrast=None) classmethod

Node Brightness/Contrast

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
brightness	Float	socket 'Brightness' (id: Bright)	None
contrast	Float	socket 'Contrast' (id: Contrast)	None

Returns:

Type	Description
Color

Source code in core/generated/static_snd.py

@classmethod
def brightness_contrast(cls, color: Color = None, brightness: Float = None, contrast: Float = None):
    """ > Node Brightness/Contrast

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    brightness : Float, optional
        socket 'Brightness' (id: Bright)

    contrast : Float, optional
        socket 'Contrast' (id: Contrast)


    Returns
    -------
    Color
    """
    node = Node('Brightness/Contrast', {'Color': color, 'Bright': brightness, 'Contrast': contrast})
    return node._out

bump(strength=None, distance=None, filter_width=None, height=None, normal=None, invert=False) classmethod

Node Bump

Parameters:

Name	Type	Description	Default
strength	Float	socket 'Strength' (id: Strength)	None
distance	Float	socket 'Distance' (id: Distance)	None
filter_width	Float	socket 'Filter Width' (id: Filter Width)	None
height	Float	socket 'Height' (id: Height)	None
normal	Vector	socket 'Normal' (id: Normal)	None
invert	bool	parameter invert	False

Returns:

Type	Description
Vector

Source code in core/generated/static_snd.py

@classmethod
def bump(cls,
                strength: Float = None,
                distance: Float = None,
                filter_width: Float = None,
                height: Float = None,
                normal: Vector = None,
                invert = False):
    """ > Node Bump

    Parameters
    ----------
    strength : Float, optional
        socket 'Strength' (id: Strength)

    distance : Float, optional
        socket 'Distance' (id: Distance)

    filter_width : Float, optional
        socket 'Filter Width' (id: Filter Width)

    height : Float, optional
        socket 'Height' (id: Height)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    invert : bool
        parameter `invert`


    Returns
    -------
    Vector
    """
    node = Node('Bump', {'Strength': strength, 'Distance': distance, 'Filter Width': filter_width, 'Height': height, 'Normal': normal}, invert=invert)
    return node._out

camera_data() classmethod

Node Camera Data

Returns:

Type	Description
Vector	peer sockets: view_z_depth_ (Float), view_distance_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def camera_data(cls):
    """ > Node Camera Data

    Returns
    -------
    Vector
        peer sockets: view_z_depth_ (Float), view_distance_ (Float)

    """
    node = Node('Camera Data', )
    return node

checker_texture(vector=None, color1=None, color2=None, scale=None) classmethod

Node Checker Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
color1	Color	socket 'Color1' (id: Color1)	None
color2	Color	socket 'Color2' (id: Color2)	None
scale	Float	socket 'Scale' (id: Scale)	None

Returns:

Type	Description
Color	peer sockets: factor_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def checker_texture(cls,
                vector: Vector = None,
                color1: Color = None,
                color2: Color = None,
                scale: Float = None):
    """ > Node Checker Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    color1 : Color, optional
        socket 'Color1' (id: Color1)

    color2 : Color, optional
        socket 'Color2' (id: Color2)

    scale : Float, optional
        socket 'Scale' (id: Scale)


    Returns
    -------
    Color
        peer sockets: factor_ (Float)

    """
    node = Node('Checker Texture', {'Vector': vector, 'Color1': color1, 'Color2': color2, 'Scale': scale})
    return node._out

clamp(value=None, min=None, max=None, clamp_type='MINMAX') classmethod

Node Clamp

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
min	Float	socket 'Min' (id: Min)	None
max	Float	socket 'Max' (id: Max)	None
clamp_type	Literal['Min Max', 'Range']	parameter clamp_type	'MINMAX'

Returns:

Type	Description
Float

Source code in core/generated/static_snd.py

@classmethod
def clamp(cls,
                value: Float = None,
                min: Float = None,
                max: Float = None,
                clamp_type: Literal['MINMAX', 'RANGE'] = 'MINMAX'):
    """ > Node Clamp

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    min : Float, optional
        socket 'Min' (id: Min)

    max : Float, optional
        socket 'Max' (id: Max)

    clamp_type : Literal['Min Max', 'Range']
        parameter `clamp_type`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Clamp', 'clamp_type', clamp_type, 'clamp', ('MINMAX', 'RANGE'))
    node = Node('Clamp', {'Value': value, 'Min': min, 'Max': max}, clamp_type=clamp_type)
    return node._out

closure_input()

Node Closure Input

Returns:

Type	Description
None

Source code in core/generated/static_snd.py

@utils.classproperty
def closure_input(self):
    """ > Node Closure Input

    Returns
    -------
    None
    """
    node = Node('Closure Input', )
    return node._out

closure_output(active_input_index=0, active_output_index=0, define_signature=False) classmethod

Node Closure Output

Parameters:

Name	Type	Description	Default
active_input_index	int	parameter active_input_index	0
active_output_index	int	parameter active_output_index	0
define_signature	bool	parameter define_signature	False

Returns:

Type	Description
Closure

Source code in core/generated/static_snd.py

@classmethod
def closure_output(cls, active_input_index = 0, active_output_index = 0, define_signature = False):
    """ > Node Closure Output

    Parameters
    ----------
    active_input_index : int
        parameter `active_input_index`

    active_output_index : int
        parameter `active_output_index`

    define_signature : bool
        parameter `define_signature`


    Returns
    -------
    Closure
    """
    node = Node('Closure Output', active_input_index=active_input_index, active_output_index=active_output_index, define_signature=define_signature)
    return node._out

color()

Node Color

Returns:

Type	Description
Color

Source code in core/generated/static_snd.py

@utils.classproperty
def color(self):
    """ > Node Color

    Returns
    -------
    Color
    """
    node = Node('Color', )
    return node._out

color_attribute(layer_name='') classmethod

Node Color Attribute

Parameters:

Name	Type	Description	Default
layer_name	str	parameter layer_name	''

Returns:

Type	Description
Color	peer sockets: alpha_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def color_attribute(cls, layer_name = ''):
    """ > Node Color Attribute

    Parameters
    ----------
    layer_name : str
        parameter `layer_name`


    Returns
    -------
    Color
        peer sockets: alpha_ (Float)

    """
    node = Node('Color Attribute', layer_name=layer_name)
    return node

color_ramp(fac=None, stops=None, interpolation='LINEAR') classmethod

Node Color Ramp

Exposes utilities to manage the color ramp

ramp1 = Float(.5).color_ramp(stops=[.1, .9])
ramp2 = ColorRamp(.5, stops=[(.1, (1, 0, 0)), (.5, 1), (.9, (0, 0, 1))])

Parameters:

Name	Type	Description	Default
fac	Float		None
stops	list[tuple[float, tuple]]	Stops made of (float, color as tuple of floats)	None
interpolation	('EASE', 'CARDINAL', 'LINEAR', 'B_SPLINE', 'CONSTANT')		'EASE'

Source code in core/generated/static_snd.py

@classmethod
def color_ramp(cls, fac=None, stops=None, interpolation='LINEAR'):
    """ Node Color Ramp

    Exposes utilities to manage the color ramp

    ``` python
    ramp1 = Float(.5).color_ramp(stops=[.1, .9])
    ramp2 = ColorRamp(.5, stops=[(.1, (1, 0, 0)), (.5, 1), (.9, (0, 0, 1))])
    ```

    Parameters
    ----------
    fac : Float, optional

    stops : list[tuple[float, tuple]]
        Stops made of (float, color as tuple of floats)

    interpolation : {'EASE', 'CARDINAL', 'LINEAR', 'B_SPLINE', 'CONSTANT'}

    """
    node = ColorRamp(fac=fac, stops=stops, interpolation=interpolation)
    return node._out

combine_bundle(named_sockets={}, define_signature=False, **sockets) classmethod

Node Combine Bundle

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
define_signature	bool	parameter define_signature	False
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
Bundle

Source code in core/generated/static_snd.py

@classmethod
def combine_bundle(cls, named_sockets: dict = {}, define_signature = False, **sockets):
    """ > Node Combine Bundle

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    define_signature : bool
        parameter `define_signature`

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    Bundle
    """
    node = Node('Combine Bundle', named_sockets, define_signature=define_signature, **sockets)
    return node._out

combine_color(red=None, green=None, blue=None, mode='RGB') classmethod

Node Combine Color

Parameters:

Name	Type	Description	Default
red	Float	socket 'Red' (id: Red)	None
green	Float	socket 'Green' (id: Green)	None
blue	Float	socket 'Blue' (id: Blue)	None
mode	Literal['RGB', 'HSV', 'HSL']	parameter mode	'RGB'

Returns:

Type	Description
Color

Source code in core/generated/static_snd.py

@classmethod
def combine_color(cls,
                red: Float = None,
                green: Float = None,
                blue: Float = None,
                mode: Literal['RGB', 'HSV', 'HSL'] = 'RGB'):
    """ > Node Combine Color

    Parameters
    ----------
    red : Float, optional
        socket 'Red' (id: Red)

    green : Float, optional
        socket 'Green' (id: Green)

    blue : Float, optional
        socket 'Blue' (id: Blue)

    mode : Literal['RGB', 'HSV', 'HSL']
        parameter `mode`


    Returns
    -------
    Color
    """
    utils.check_enum_arg('Combine Color', 'mode', mode, 'combine_color', ('RGB', 'HSV', 'HSL'))
    node = Node('Combine Color', {'Red': red, 'Green': green, 'Blue': blue}, mode=mode)
    return node._out

combine_xyz(x=None, y=None, z=None) classmethod

Node Combine XYZ

Parameters:

Name	Type	Description	Default
x	Float	socket 'X' (id: X)	None
y	Float	socket 'Y' (id: Y)	None
z	Float	socket 'Z' (id: Z)	None

Returns:

Type	Description
Vector

Source code in core/generated/static_snd.py

@classmethod
def combine_xyz(cls, x: Float = None, y: Float = None, z: Float = None):
    """ > Node Combine XYZ

    Parameters
    ----------
    x : Float, optional
        socket 'X' (id: X)

    y : Float, optional
        socket 'Y' (id: Y)

    z : Float, optional
        socket 'Z' (id: Z)


    Returns
    -------
    Vector
    """
    node = Node('Combine XYZ', {'X': x, 'Y': y, 'Z': z})
    return node._out

curves_info() classmethod

Node Curves Info

Returns:

Type	Description
Float	peer sockets: intercept_ (Float), length_ (Float), thickness_ (Float), tangent_normal_ (Vector), random_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def curves_info(cls):
    """ > Node Curves Info

    Returns
    -------
    Float
        peer sockets: intercept_ (Float), length_ (Float), thickness_ (Float), tangent_normal_ (Vector), random_ (Float)

    """
    node = Node('Curves Info', )
    return node

diffuse_bsdf(color=None, roughness=None, normal=None, weight=None) classmethod

Node Diffuse BSDF

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
normal	Vector	socket 'Normal' (id: Normal)	None
weight	Float	socket 'Weight' (id: Weight)	None

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def diffuse_bsdf(cls,
                color: Color = None,
                roughness: Float = None,
                normal: Vector = None,
                weight: Float = None):
    """ > Node Diffuse BSDF

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    weight : Float, optional
        socket 'Weight' (id: Weight)


    Returns
    -------
    Shader
    """
    node = Node('Diffuse BSDF', {'Color': color, 'Roughness': roughness, 'Normal': normal, 'Weight': weight})
    return node._out

displacement(height=None, midlevel=None, scale=None, normal=None, space='OBJECT') classmethod

Node Displacement

Parameters:

Name	Type	Description	Default
height	Float	socket 'Height' (id: Height)	None
midlevel	Float	socket 'Midlevel' (id: Midlevel)	None
scale	Float	socket 'Scale' (id: Scale)	None
normal	Vector	socket 'Normal' (id: Normal)	None
space	Literal['Object Space', 'World Space']	parameter space	'OBJECT'

Returns:

Type	Description
Vector

Source code in core/generated/static_snd.py

@classmethod
def displacement(cls,
                height: Float = None,
                midlevel: Float = None,
                scale: Float = None,
                normal: Vector = None,
                space: Literal['OBJECT', 'WORLD'] = 'OBJECT'):
    """ > Node Displacement

    Parameters
    ----------
    height : Float, optional
        socket 'Height' (id: Height)

    midlevel : Float, optional
        socket 'Midlevel' (id: Midlevel)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    space : Literal['Object Space', 'World Space']
        parameter `space`


    Returns
    -------
    Vector
    """
    utils.check_enum_arg('Displacement', 'space', space, 'displacement', ('OBJECT', 'WORLD'))
    node = Node('Displacement', {'Height': height, 'Midlevel': midlevel, 'Scale': scale, 'Normal': normal}, space=space)
    return node._out

emission(color=None, strength=None, weight=None) classmethod

Node Emission

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
strength	Float	socket 'Strength' (id: Strength)	None
weight	Float	socket 'Weight' (id: Weight)	None

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def emission(cls, color: Color = None, strength: Float = None, weight: Float = None):
    """ > Node Emission

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    strength : Float, optional
        socket 'Strength' (id: Strength)

    weight : Float, optional
        socket 'Weight' (id: Weight)


    Returns
    -------
    Shader
    """
    node = Node('Emission', {'Color': color, 'Strength': strength, 'Weight': weight})
    return node._out

environment_texture(vector=None, image=None, interpolation='Linear', projection='EQUIRECTANGULAR') classmethod

Node Environment Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
image	NoneType	parameter image	None
interpolation	Literal['Linear', 'Closest', 'Cubic', 'Smart']	parameter interpolation	'Linear'
projection	Literal['Equirectangular', 'Mirror Ball']	parameter projection	'EQUIRECTANGULAR'

Returns:

Type	Description
Color

Source code in core/generated/static_snd.py

@classmethod
def environment_texture(cls,
                vector: Vector = None,
                image = None,
                interpolation: Literal['Linear', 'Closest', 'Cubic', 'Smart'] = 'Linear',
                projection: Literal['EQUIRECTANGULAR', 'MIRROR_BALL'] = 'EQUIRECTANGULAR'):
    """ > Node Environment Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    image : NoneType
        parameter `image`

    interpolation : Literal['Linear', 'Closest', 'Cubic', 'Smart']
        parameter `interpolation`

    projection : Literal['Equirectangular', 'Mirror Ball']
        parameter `projection`


    Returns
    -------
    Color
    """
    utils.check_enum_arg('Environment Texture', 'interpolation', interpolation, 'environment_texture', ('Linear', 'Closest', 'Cubic', 'Smart'))
    utils.check_enum_arg('Environment Texture', 'projection', projection, 'environment_texture', ('EQUIRECTANGULAR', 'MIRROR_BALL'))
    node = Node('Environment Texture', {'Vector': vector}, image=image, interpolation=interpolation, projection=projection)
    return node._out

evaluate_closure(closure=None, active_input_index=0, active_output_index=0, define_signature=False) classmethod

Node Evaluate Closure

Parameters:

Name	Type	Description	Default
closure	Closure	socket 'Closure' (id: Closure)	None
active_input_index	int	parameter active_input_index	0
active_output_index	int	parameter active_output_index	0
define_signature	bool	parameter define_signature	False

Returns:

Type	Description
None

Source code in core/generated/static_snd.py

@classmethod
def evaluate_closure(cls,
                closure: Closure = None,
                active_input_index = 0,
                active_output_index = 0,
                define_signature = False):
    """ > Node Evaluate Closure

    Parameters
    ----------
    closure : Closure, optional
        socket 'Closure' (id: Closure)

    active_input_index : int
        parameter `active_input_index`

    active_output_index : int
        parameter `active_output_index`

    define_signature : bool
        parameter `define_signature`


    Returns
    -------
    None
    """
    node = Node('Evaluate Closure', {'Closure': closure}, active_input_index=active_input_index, active_output_index=active_output_index, define_signature=define_signature)
    return node._out

float_curve(value=None, factor=None) classmethod

Node Float Curve

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
factor	Float	socket 'Factor' (id: Factor)	None

Returns:

Type	Description
Float

Source code in core/generated/static_snd.py

@classmethod
def float_curve(cls, value: Float = None, factor: Float = None):
    """ > Node Float Curve

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    factor : Float, optional
        socket 'Factor' (id: Factor)


    Returns
    -------
    Float
    """
    node = NodeCurves('Float Curve', {'Value': value, 'Factor': factor})
    return node._out

frame(label_size=20, shrink=True, text=None) classmethod

Node Frame

Parameters:

Name	Type	Description	Default
label_size	int	parameter label_size	20
shrink	bool	parameter shrink	True
text	NoneType	parameter text	None

Returns:

Type	Description
None

Source code in core/generated/static_snd.py

@classmethod
def frame(cls, label_size = 20, shrink = True, text = None):
    """ > Node Frame

    Parameters
    ----------
    label_size : int
        parameter `label_size`

    shrink : bool
        parameter `shrink`

    text : NoneType
        parameter `text`


    Returns
    -------
    None
    """
    node = Node('Frame', label_size=label_size, shrink=shrink, text=text)
    return node._out

fresnel(ior=None, normal=None) classmethod

Node Fresnel

Parameters:

Name	Type	Description	Default
ior	Float	socket 'IOR' (id: IOR)	None
normal	Vector	socket 'Normal' (id: Normal)	None

Returns:

Type	Description
Float

Source code in core/generated/static_snd.py

@classmethod
def fresnel(cls, ior: Float = None, normal: Vector = None):
    """ > Node Fresnel

    Parameters
    ----------
    ior : Float, optional
        socket 'IOR' (id: IOR)

    normal : Vector, optional
        socket 'Normal' (id: Normal)


    Returns
    -------
    Float
    """
    node = Node('Fresnel', {'IOR': ior, 'Normal': normal})
    return node._out

gabor_texture(vector=None, scale=None, frequency=None, anisotropy=None, orientation=None, orientation_1=None, gabor_type='2D') classmethod

Node Gabor Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
scale	Float	socket 'Scale' (id: Scale)	None
frequency	Float	socket 'Frequency' (id: Frequency)	None
anisotropy	Float	socket 'Anisotropy' (id: Anisotropy)	None
orientation	Float	socket 'Orientation' (id: Orientation 2D)	None
orientation_1	Vector	socket 'Orientation' (id: Orientation 3D)	None
gabor_type	Literal['2D', '3D']	parameter gabor_type	'2D'

Returns:

Type	Description
Float	peer sockets: phase_ (Float), intensity_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def gabor_texture(cls,
                vector: Vector = None,
                scale: Float = None,
                frequency: Float = None,
                anisotropy: Float = None,
                orientation: Float = None,
                orientation_1: Vector = None,
                gabor_type: Literal['2D', '3D'] = '2D'):
    """ > Node Gabor Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    frequency : Float, optional
        socket 'Frequency' (id: Frequency)

    anisotropy : Float, optional
        socket 'Anisotropy' (id: Anisotropy)

    orientation : Float, optional
        socket 'Orientation' (id: Orientation 2D)

    orientation_1 : Vector, optional
        socket 'Orientation' (id: Orientation 3D)

    gabor_type : Literal['2D', '3D']
        parameter `gabor_type`


    Returns
    -------
    Float
        peer sockets: phase_ (Float), intensity_ (Float)

    """
    utils.check_enum_arg('Gabor Texture', 'gabor_type', gabor_type, 'gabor_texture', ('2D', '3D'))
    node = Node('Gabor Texture', {'Vector': vector, 'Scale': scale, 'Frequency': frequency, 'Anisotropy': anisotropy, 'Orientation 2D': orientation, 'Orientation 3D': orientation_1}, gabor_type=gabor_type)
    return node._out

gamma(color=None, gamma=None) classmethod

Node Gamma

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
gamma	Float	socket 'Gamma' (id: Gamma)	None

Returns:

Type	Description
Color

Source code in core/generated/static_snd.py

@classmethod
def gamma(cls, color: Color = None, gamma: Float = None):
    """ > Node Gamma

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    gamma : Float, optional
        socket 'Gamma' (id: Gamma)


    Returns
    -------
    Color
    """
    node = Node('Gamma', {'Color': color, 'Gamma': gamma})
    return node._out

geometry() classmethod

Node Geometry

Returns:

Type	Description
Vector	peer sockets: normal_ (Vector), tangent_ (Vector), true_normal_ (Vector), incoming_ (Vector), parametric_ (Vector), backfacing_ (Float), pointiness_ (Float), random_per_island_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def geometry(cls):
    """ > Node Geometry

    Returns
    -------
    Vector
        peer sockets: normal_ (Vector), tangent_ (Vector), true_normal_ (Vector), incoming_ (Vector), parametric_ (Vector), backfacing_ (Float), pointiness_ (Float), random_per_island_ (Float)

    """
    node = Node('Geometry', )
    return node

glass_bsdf(color=None, roughness=None, ior=None, normal=None, weight=None, thin_film_thickness=None, thin_film_ior=None, distribution='MULTI_GGX') classmethod

Node Glass BSDF

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
ior	Float	socket 'IOR' (id: IOR)	None
normal	Vector	socket 'Normal' (id: Normal)	None
weight	Float	socket 'Weight' (id: Weight)	None
thin_film_thickness	Float	socket 'Thin Film Thickness' (id: Thin Film Thickness)	None
thin_film_ior	Float	socket 'Thin Film IOR' (id: Thin Film IOR)	None
distribution	Literal['Beckmann', 'GGX', 'Multiscatter GGX']	parameter distribution	'MULTI_GGX'

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def glass_bsdf(cls,
                color: Color = None,
                roughness: Float = None,
                ior: Float = None,
                normal: Vector = None,
                weight: Float = None,
                thin_film_thickness: Float = None,
                thin_film_ior: Float = None,
                distribution: Literal['BECKMANN', 'GGX', 'MULTI_GGX'] = 'MULTI_GGX'):
    """ > Node Glass BSDF

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    ior : Float, optional
        socket 'IOR' (id: IOR)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    weight : Float, optional
        socket 'Weight' (id: Weight)

    thin_film_thickness : Float, optional
        socket 'Thin Film Thickness' (id: Thin Film Thickness)

    thin_film_ior : Float, optional
        socket 'Thin Film IOR' (id: Thin Film IOR)

    distribution : Literal['Beckmann', 'GGX', 'Multiscatter GGX']
        parameter `distribution`


    Returns
    -------
    Shader
    """
    utils.check_enum_arg('Glass BSDF', 'distribution', distribution, 'glass_bsdf', ('BECKMANN', 'GGX', 'MULTI_GGX'))
    node = Node('Glass BSDF', {'Color': color, 'Roughness': roughness, 'IOR': ior, 'Normal': normal, 'Weight': weight, 'Thin Film Thickness': thin_film_thickness, 'Thin Film IOR': thin_film_ior}, distribution=distribution)
    return node._out

glossy_bsdf(color=None, roughness=None, anisotropy=None, rotation=None, normal=None, tangent=None, weight=None, distribution='MULTI_GGX') classmethod

Node Glossy BSDF

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
anisotropy	Float	socket 'Anisotropy' (id: Anisotropy)	None
rotation	Float	socket 'Rotation' (id: Rotation)	None
normal	Vector	socket 'Normal' (id: Normal)	None
tangent	Vector	socket 'Tangent' (id: Tangent)	None
weight	Float	socket 'Weight' (id: Weight)	None
distribution	Literal['Beckmann', 'GGX', 'Ashikhmin-Shirley', 'Multiscatter GGX']	parameter distribution	'MULTI_GGX'

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def glossy_bsdf(cls,
                color: Color = None,
                roughness: Float = None,
                anisotropy: Float = None,
                rotation: Float = None,
                normal: Vector = None,
                tangent: Vector = None,
                weight: Float = None,
                distribution: Literal['BECKMANN', 'GGX', 'ASHIKHMIN_SHIRLEY', 'MULTI_GGX'] = 'MULTI_GGX'):
    """ > Node Glossy BSDF

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    anisotropy : Float, optional
        socket 'Anisotropy' (id: Anisotropy)

    rotation : Float, optional
        socket 'Rotation' (id: Rotation)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    tangent : Vector, optional
        socket 'Tangent' (id: Tangent)

    weight : Float, optional
        socket 'Weight' (id: Weight)

    distribution : Literal['Beckmann', 'GGX', 'Ashikhmin-Shirley', 'Multiscatter GGX']
        parameter `distribution`


    Returns
    -------
    Shader
    """
    utils.check_enum_arg('Glossy BSDF', 'distribution', distribution, 'glossy_bsdf', ('BECKMANN', 'GGX', 'ASHIKHMIN_SHIRLEY', 'MULTI_GGX'))
    node = Node('Glossy BSDF', {'Color': color, 'Roughness': roughness, 'Anisotropy': anisotropy, 'Rotation': rotation, 'Normal': normal, 'Tangent': tangent, 'Weight': weight}, distribution=distribution)
    return node._out

gradient_texture(vector=None, gradient_type='LINEAR') classmethod

Node Gradient Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
gradient_type	Literal['Linear', 'Quadratic', 'Easing', 'Diagonal', 'Spherical', 'Quadratic Sphere', 'Radial']	parameter gradient_type	'LINEAR'

Returns:

Type	Description
Color	peer sockets: factor_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def gradient_texture(cls,
                vector: Vector = None,
                gradient_type: Literal['LINEAR', 'QUADRATIC', 'EASING', 'DIAGONAL', 'SPHERICAL', 'QUADRATIC_SPHERE', 'RADIAL'] = 'LINEAR'):
    """ > Node Gradient Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    gradient_type : Literal['Linear', 'Quadratic', 'Easing', 'Diagonal', 'Spherical', 'Quadratic Sphere', 'Radial']
        parameter `gradient_type`


    Returns
    -------
    Color
        peer sockets: factor_ (Float)

    """
    utils.check_enum_arg('Gradient Texture', 'gradient_type', gradient_type, 'gradient_texture', ('LINEAR', 'QUADRATIC', 'EASING', 'DIAGONAL', 'SPHERICAL', 'QUADRATIC_SPHERE', 'RADIAL'))
    node = Node('Gradient Texture', {'Vector': vector}, gradient_type=gradient_type)
    return node._out

group(node_tree=None) classmethod

Node Group

Parameters:

Name	Type	Description	Default
node_tree	NoneType	parameter node_tree	None

Returns:

Type	Description
None

Source code in core/generated/static_snd.py

@classmethod
def group(cls, node_tree = None):
    """ > Node Group

    Parameters
    ----------
    node_tree : NoneType
        parameter `node_tree`


    Returns
    -------
    None
    """
    node = Node('Group', node_tree=node_tree)
    return node._out

group_input()

Node Group Input

Returns:

Type	Description
None

Source code in core/generated/static_snd.py

@utils.classproperty
def group_input(self):
    """ > Node Group Input

    Returns
    -------
    None
    """
    node = Node('Group Input', )
    return node._out

group_output(is_active_output=True) classmethod

Node Group Output

Parameters:

Name	Type	Description	Default
is_active_output	bool	parameter is_active_output	True

Returns:

Type	Description
None

Source code in core/generated/static_snd.py

@classmethod
def group_output(cls, is_active_output = True):
    """ > Node Group Output

    Parameters
    ----------
    is_active_output : bool
        parameter `is_active_output`


    Returns
    -------
    None
    """
    node = Node('Group Output', is_active_output=is_active_output)
    return node._out

hair_bsdf(color=None, offset=None, roughnessu=None, roughnessv=None, tangent=None, weight=None, component='Reflection') classmethod

Node Hair BSDF

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
offset	Float	socket 'Offset' (id: Offset)	None
roughnessu	Float	socket 'RoughnessU' (id: RoughnessU)	None
roughnessv	Float	socket 'RoughnessV' (id: RoughnessV)	None
tangent	Vector	socket 'Tangent' (id: Tangent)	None
weight	Float	socket 'Weight' (id: Weight)	None
component	Literal['Reflection', 'Transmission']	parameter component	'Reflection'

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def hair_bsdf(cls,
                color: Color = None,
                offset: Float = None,
                roughnessu: Float = None,
                roughnessv: Float = None,
                tangent: Vector = None,
                weight: Float = None,
                component: Literal['Reflection', 'Transmission'] = 'Reflection'):
    """ > Node Hair BSDF

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    offset : Float, optional
        socket 'Offset' (id: Offset)

    roughnessu : Float, optional
        socket 'RoughnessU' (id: RoughnessU)

    roughnessv : Float, optional
        socket 'RoughnessV' (id: RoughnessV)

    tangent : Vector, optional
        socket 'Tangent' (id: Tangent)

    weight : Float, optional
        socket 'Weight' (id: Weight)

    component : Literal['Reflection', 'Transmission']
        parameter `component`


    Returns
    -------
    Shader
    """
    utils.check_enum_arg('Hair BSDF', 'component', component, 'hair_bsdf', ('Reflection', 'Transmission'))
    node = Node('Hair BSDF', {'Color': color, 'Offset': offset, 'RoughnessU': roughnessu, 'RoughnessV': roughnessv, 'Tangent': tangent, 'Weight': weight}, component=component)
    return node._out

holdout(weight=None) classmethod

Node Holdout

Parameters:

Name	Type	Description	Default
weight	Float	socket 'Weight' (id: Weight)	None

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def holdout(cls, weight: Float = None):
    """ > Node Holdout

    Parameters
    ----------
    weight : Float, optional
        socket 'Weight' (id: Weight)


    Returns
    -------
    Shader
    """
    node = Node('Holdout', {'Weight': weight})
    return node._out

hue_saturation_value(hue=None, saturation=None, value=None, color=None, factor=None) classmethod

Node Hue/Saturation/Value

Parameters:

Name	Type	Description	Default
hue	Float	socket 'Hue' (id: Hue)	None
saturation	Float	socket 'Saturation' (id: Saturation)	None
value	Float	socket 'Value' (id: Value)	None
color	Color	socket 'Color' (id: Color)	None
factor	Float	socket 'Factor' (id: Fac)	None

Returns:

Type	Description
Color

Source code in core/generated/static_snd.py

@classmethod
def hue_saturation_value(cls,
                hue: Float = None,
                saturation: Float = None,
                value: Float = None,
                color: Color = None,
                factor: Float = None):
    """ > Node Hue/Saturation/Value

    Parameters
    ----------
    hue : Float, optional
        socket 'Hue' (id: Hue)

    saturation : Float, optional
        socket 'Saturation' (id: Saturation)

    value : Float, optional
        socket 'Value' (id: Value)

    color : Color, optional
        socket 'Color' (id: Color)

    factor : Float, optional
        socket 'Factor' (id: Fac)


    Returns
    -------
    Color
    """
    node = Node('Hue/Saturation/Value', {'Hue': hue, 'Saturation': saturation, 'Value': value, 'Color': color, 'Fac': factor})
    return node._out

ies_texture(vector=None, strength=None, filepath='', ies=None, mode='INTERNAL') classmethod

Node IES Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
strength	Float	socket 'Strength' (id: Strength)	None
filepath	str	parameter filepath	''
ies	NoneType	parameter ies	None
mode	Literal['Internal', 'External']	parameter mode	'INTERNAL'

Returns:

Type	Description
Float

Source code in core/generated/static_snd.py

@classmethod
def ies_texture(cls,
                vector: Vector = None,
                strength: Float = None,
                filepath = '',
                ies = None,
                mode: Literal['INTERNAL', 'EXTERNAL'] = 'INTERNAL'):
    """ > Node IES Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    strength : Float, optional
        socket 'Strength' (id: Strength)

    filepath : str
        parameter `filepath`

    ies : NoneType
        parameter `ies`

    mode : Literal['Internal', 'External']
        parameter `mode`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('IES Texture', 'mode', mode, 'ies_texture', ('INTERNAL', 'EXTERNAL'))
    node = Node('IES Texture', {'Vector': vector, 'Strength': strength}, filepath=filepath, ies=ies, mode=mode)
    return node._out

image_texture(vector=None, extension='REPEAT', image=None, interpolation='Linear', projection='FLAT', projection_blend=0.0) classmethod

Node Image Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
extension	Literal['Repeat', 'Extend', 'Clip', 'Mirror']	parameter extension	'REPEAT'
image	NoneType	parameter image	None
interpolation	Literal['Linear', 'Closest', 'Cubic', 'Smart']	parameter interpolation	'Linear'
projection	Literal['Flat', 'Box', 'Sphere', 'Tube']	parameter projection	'FLAT'
projection_blend	float	parameter projection_blend	0.0

Returns:

Type	Description
Color	peer sockets: alpha_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def image_texture(cls,
                vector: Vector = None,
                extension: Literal['REPEAT', 'EXTEND', 'CLIP', 'MIRROR'] = 'REPEAT',
                image = None,
                interpolation: Literal['Linear', 'Closest', 'Cubic', 'Smart'] = 'Linear',
                projection: Literal['FLAT', 'BOX', 'SPHERE', 'TUBE'] = 'FLAT',
                projection_blend = 0.0):
    """ > Node Image Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    extension : Literal['Repeat', 'Extend', 'Clip', 'Mirror']
        parameter `extension`

    image : NoneType
        parameter `image`

    interpolation : Literal['Linear', 'Closest', 'Cubic', 'Smart']
        parameter `interpolation`

    projection : Literal['Flat', 'Box', 'Sphere', 'Tube']
        parameter `projection`

    projection_blend : float
        parameter `projection_blend`


    Returns
    -------
    Color
        peer sockets: alpha_ (Float)

    """
    utils.check_enum_arg('Image Texture', 'extension', extension, 'image_texture', ('REPEAT', 'EXTEND', 'CLIP', 'MIRROR'))
    utils.check_enum_arg('Image Texture', 'interpolation', interpolation, 'image_texture', ('Linear', 'Closest', 'Cubic', 'Smart'))
    utils.check_enum_arg('Image Texture', 'projection', projection, 'image_texture', ('FLAT', 'BOX', 'SPHERE', 'TUBE'))
    node = Node('Image Texture', {'Vector': vector}, extension=extension, image=image, interpolation=interpolation, projection=projection, projection_blend=projection_blend)
    return node._out

invert_color(color=None, factor=None) classmethod

Node Invert Color

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
factor	Float	socket 'Factor' (id: Fac)	None

Returns:

Type	Description
Color

Source code in core/generated/static_snd.py

@classmethod
def invert_color(cls, color: Color = None, factor: Float = None):
    """ > Node Invert Color

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    factor : Float, optional
        socket 'Factor' (id: Fac)


    Returns
    -------
    Color
    """
    node = Node('Invert Color', {'Color': color, 'Fac': factor})
    return node._out

join_bundle(*bundle) classmethod

Node Join Bundle

Parameters:

Name	Type	Description	Default
bundle	Bundle	socket 'Bundle' (id: Bundle)	()

Returns:

Type	Description
Bundle

Source code in core/generated/static_snd.py

@classmethod
def join_bundle(cls, *bundle: Bundle):
    """ > Node Join Bundle

    Parameters
    ----------
    bundle : Bundle, optional
        socket 'Bundle' (id: Bundle)


    Returns
    -------
    Bundle
    """
    node = Node('Join Bundle', {'Bundle': list(bundle)})
    return node._out

layer_weight(blend=None, normal=None) classmethod

Node Layer Weight

Parameters:

Name	Type	Description	Default
blend	Float	socket 'Blend' (id: Blend)	None
normal	Vector	socket 'Normal' (id: Normal)	None

Returns:

Type	Description
Float	peer sockets: facing_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def layer_weight(cls, blend: Float = None, normal: Vector = None):
    """ > Node Layer Weight

    Parameters
    ----------
    blend : Float, optional
        socket 'Blend' (id: Blend)

    normal : Vector, optional
        socket 'Normal' (id: Normal)


    Returns
    -------
    Float
        peer sockets: facing_ (Float)

    """
    node = Node('Layer Weight', {'Blend': blend, 'Normal': normal})
    return node._out

light_falloff(strength=None, smooth=None) classmethod

Node Light Falloff

Parameters:

Name	Type	Description	Default
strength	Float	socket 'Strength' (id: Strength)	None
smooth	Float	socket 'Smooth' (id: Smooth)	None

Returns:

Type	Description
Float	peer sockets: linear_ (Float), constant_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def light_falloff(cls, strength: Float = None, smooth: Float = None):
    """ > Node Light Falloff

    Parameters
    ----------
    strength : Float, optional
        socket 'Strength' (id: Strength)

    smooth : Float, optional
        socket 'Smooth' (id: Smooth)


    Returns
    -------
    Float
        peer sockets: linear_ (Float), constant_ (Float)

    """
    node = Node('Light Falloff', {'Strength': strength, 'Smooth': smooth})
    return node._out

light_output(surface=None, is_active_output=True, target='ALL') classmethod

Node Light Output

Parameters:

Name	Type	Description	Default
surface	Shader	socket 'Surface' (id: Surface)	None
is_active_output	bool	parameter is_active_output	True
target	Literal['All', 'EEVEE', 'Cycles']	parameter target	'ALL'

Returns:

Type	Description
None

Source code in core/generated/static_snd.py

@classmethod
def light_output(cls,
                surface: Shader = None,
                is_active_output = True,
                target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL'):
    """ > Node Light Output

    Parameters
    ----------
    surface : Shader, optional
        socket 'Surface' (id: Surface)

    is_active_output : bool
        parameter `is_active_output`

    target : Literal['All', 'EEVEE', 'Cycles']
        parameter `target`


    Returns
    -------
    None
    """
    utils.check_enum_arg('Light Output', 'target', target, 'light_output', ('ALL', 'EEVEE', 'CYCLES'))
    node = Node('Light Output', {'Surface': surface}, is_active_output=is_active_output, target=target)
    return node._out

light_path() classmethod

Node Light Path

Returns:

Type	Description
Float	peer sockets: is_shadow_ray_ (Float), is_diffuse_ray_ (Float), is_glossy_ray_ (Float), is_singular_ray_ (Float), is_reflection_ray_ (Float), is_transmission_ray_ (Float), is_volume_scatter_ray_ (Float), ray_length_ (Float), ray_depth_ (Float), diffuse_depth_ (Float), glossy_depth_ (Float), transparent_depth_ (Float), transmission_depth_ (Float), portal_depth_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def light_path(cls):
    """ > Node Light Path

    Returns
    -------
    Float
        peer sockets: is_shadow_ray_ (Float), is_diffuse_ray_ (Float), is_glossy_ray_ (Float), is_singular_ray_ (Float), is_reflection_ray_ (Float), is_transmission_ray_ (Float), is_volume_scatter_ray_ (Float), ray_length_ (Float), ray_depth_ (Float), diffuse_depth_ (Float), glossy_depth_ (Float), transparent_depth_ (Float), transmission_depth_ (Float), portal_depth_ (Float)

    """
    node = Node('Light Path', )
    return node

line_style_output(color=None, color_fac=None, alpha=None, alpha_fac=None, blend_type='MIX', is_active_output=True, target='ALL', use_alpha=False, use_clamp=False) classmethod

Node Line Style Output

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
color_fac	Float	socket 'Color Fac' (id: Color Fac)	None
alpha	Float	socket 'Alpha' (id: Alpha)	None
alpha_fac	Float	socket 'Alpha Fac' (id: Alpha Fac)	None
blend_type	Literal['Mix', 'Darken', 'Multiply', 'Color Burn', 'Lighten', 'Screen', 'Color Dodge', 'Add', 'Overlay', 'Soft Light', 'Linear Light', 'Difference', 'Exclusion', 'Subtract', 'Divide', 'Hue', 'Saturation', 'Color', 'Value']	parameter blend_type	'MIX'
is_active_output	bool	parameter is_active_output	True
target	Literal['All', 'EEVEE', 'Cycles']	parameter target	'ALL'
use_alpha	bool	parameter use_alpha	False
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
None

Source code in core/generated/static_snd.py

@classmethod
def line_style_output(cls,
                color: Color = None,
                color_fac: Float = None,
                alpha: Float = None,
                alpha_fac: Float = None,
                blend_type: Literal['MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'] = 'MIX',
                is_active_output = True,
                target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL',
                use_alpha = False,
                use_clamp = False):
    """ > Node Line Style Output

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    color_fac : Float, optional
        socket 'Color Fac' (id: Color Fac)

    alpha : Float, optional
        socket 'Alpha' (id: Alpha)

    alpha_fac : Float, optional
        socket 'Alpha Fac' (id: Alpha Fac)

    blend_type : Literal['Mix', 'Darken', 'Multiply', 'Color Burn', 'Lighten', 'Screen', 'Color Dodge', 'Add', 'Overlay', 'Soft Light', 'Linear Light', 'Difference', 'Exclusion', 'Subtract', 'Divide', 'Hue', 'Saturation', 'Color', 'Value']
        parameter `blend_type`

    is_active_output : bool
        parameter `is_active_output`

    target : Literal['All', 'EEVEE', 'Cycles']
        parameter `target`

    use_alpha : bool
        parameter `use_alpha`

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    None
    """
    utils.check_enum_arg('Line Style Output', 'blend_type', blend_type, 'line_style_output', ('MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'))
    utils.check_enum_arg('Line Style Output', 'target', target, 'line_style_output', ('ALL', 'EEVEE', 'CYCLES'))
    node = Node('Line Style Output', {'Color': color, 'Color Fac': color_fac, 'Alpha': alpha, 'Alpha Fac': alpha_fac}, blend_type=blend_type, is_active_output=is_active_output, target=target, use_alpha=use_alpha, use_clamp=use_clamp)
    return node._out

magic_texture(vector=None, scale=None, distortion=None, turbulence_depth=2) classmethod

Node Magic Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
scale	Float	socket 'Scale' (id: Scale)	None
distortion	Float	socket 'Distortion' (id: Distortion)	None
turbulence_depth	int	parameter turbulence_depth	2

Returns:

Type	Description
Color	peer sockets: factor_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def magic_texture(cls,
                vector: Vector = None,
                scale: Float = None,
                distortion: Float = None,
                turbulence_depth = 2):
    """ > Node Magic Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    distortion : Float, optional
        socket 'Distortion' (id: Distortion)

    turbulence_depth : int
        parameter `turbulence_depth`


    Returns
    -------
    Color
        peer sockets: factor_ (Float)

    """
    node = Node('Magic Texture', {'Vector': vector, 'Scale': scale, 'Distortion': distortion}, turbulence_depth=turbulence_depth)
    return node._out

map_range(value=None, from_min=None, from_max=None, to_min=None, to_max=None, steps=None, vector=None, from_min_1=None, from_max_1=None, to_min_1=None, to_max_1=None, steps_1=None, clamp=True, data_type='FLOAT', interpolation_type='LINEAR') classmethod

Node Map Range

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
from_min	Float	socket 'From Min' (id: From Min)	None
from_max	Float	socket 'From Max' (id: From Max)	None
to_min	Float	socket 'To Min' (id: To Min)	None
to_max	Float	socket 'To Max' (id: To Max)	None
steps	Float	socket 'Steps' (id: Steps)	None
vector	Vector	socket 'Vector' (id: Vector)	None
from_min_1	Vector	socket 'From Min' (id: From_Min_FLOAT3)	None
from_max_1	Vector	socket 'From Max' (id: From_Max_FLOAT3)	None
to_min_1	Vector	socket 'To Min' (id: To_Min_FLOAT3)	None
to_max_1	Vector	socket 'To Max' (id: To_Max_FLOAT3)	None
steps_1	Vector	socket 'Steps' (id: Steps_FLOAT3)	None
clamp	bool	parameter clamp	True
data_type	Literal['Float', 'Vector']	parameter data_type	'FLOAT'
interpolation_type	Literal['Linear', 'Stepped Linear', 'Smooth Step', 'Smoother Step']	parameter interpolation_type	'LINEAR'

Returns:

Type	Description
Float

Source code in core/generated/static_snd.py

@classmethod
def map_range(cls,
                value: Float = None,
                from_min: Float = None,
                from_max: Float = None,
                to_min: Float = None,
                to_max: Float = None,
                steps: Float = None,
                vector: Vector = None,
                from_min_1: Vector = None,
                from_max_1: Vector = None,
                to_min_1: Vector = None,
                to_max_1: Vector = None,
                steps_1: Vector = None,
                clamp = True,
                data_type: Literal['FLOAT', 'FLOAT_VECTOR'] = 'FLOAT',
                interpolation_type: Literal['LINEAR', 'STEPPED', 'SMOOTHSTEP', 'SMOOTHERSTEP'] = 'LINEAR'):
    """ > Node Map Range

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    from_min : Float, optional
        socket 'From Min' (id: From Min)

    from_max : Float, optional
        socket 'From Max' (id: From Max)

    to_min : Float, optional
        socket 'To Min' (id: To Min)

    to_max : Float, optional
        socket 'To Max' (id: To Max)

    steps : Float, optional
        socket 'Steps' (id: Steps)

    vector : Vector, optional
        socket 'Vector' (id: Vector)

    from_min_1 : Vector, optional
        socket 'From Min' (id: From_Min_FLOAT3)

    from_max_1 : Vector, optional
        socket 'From Max' (id: From_Max_FLOAT3)

    to_min_1 : Vector, optional
        socket 'To Min' (id: To_Min_FLOAT3)

    to_max_1 : Vector, optional
        socket 'To Max' (id: To_Max_FLOAT3)

    steps_1 : Vector, optional
        socket 'Steps' (id: Steps_FLOAT3)

    clamp : bool
        parameter `clamp`

    data_type : Literal['Float', 'Vector']
        parameter `data_type`

    interpolation_type : Literal['Linear', 'Stepped Linear', 'Smooth Step', 'Smoother Step']
        parameter `interpolation_type`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Map Range', 'interpolation_type', interpolation_type, 'map_range', ('LINEAR', 'STEPPED', 'SMOOTHSTEP', 'SMOOTHERSTEP'))
    node = Node('Map Range', {'Value': value, 'From Min': from_min, 'From Max': from_max, 'To Min': to_min, 'To Max': to_max, 'Steps': steps, 'Vector': vector, 'From_Min_FLOAT3': from_min_1, 'From_Max_FLOAT3': from_max_1, 'To_Min_FLOAT3': to_min_1, 'To_Max_FLOAT3': to_max_1, 'Steps_FLOAT3': steps_1}, clamp=clamp, data_type=data_type, interpolation_type=interpolation_type)
    return node._out

mapping(vector=None, location=None, rotation=None, scale=None, vector_type='POINT') classmethod

Node Mapping

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
location	Vector	socket 'Location' (id: Location)	None
rotation	Vector	socket 'Rotation' (id: Rotation)	None
scale	Vector	socket 'Scale' (id: Scale)	None
vector_type	Literal['Point', 'Texture', 'Vector', 'Normal']	parameter vector_type	'POINT'

Returns:

Type	Description
Vector

Source code in core/generated/static_snd.py

@classmethod
def mapping(cls,
                vector: Vector = None,
                location: Vector = None,
                rotation: Vector = None,
                scale: Vector = None,
                vector_type: Literal['POINT', 'TEXTURE', 'VECTOR', 'NORMAL'] = 'POINT'):
    """ > Node Mapping

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    location : Vector, optional
        socket 'Location' (id: Location)

    rotation : Vector, optional
        socket 'Rotation' (id: Rotation)

    scale : Vector, optional
        socket 'Scale' (id: Scale)

    vector_type : Literal['Point', 'Texture', 'Vector', 'Normal']
        parameter `vector_type`


    Returns
    -------
    Vector
    """
    utils.check_enum_arg('Mapping', 'vector_type', vector_type, 'mapping', ('POINT', 'TEXTURE', 'VECTOR', 'NORMAL'))
    node = Node('Mapping', {'Vector': vector, 'Location': location, 'Rotation': rotation, 'Scale': scale}, vector_type=vector_type)
    return node._out

material_output(surface=None, volume=None, displacement=None, thickness=None, is_active_output=True, target='ALL') classmethod

Node Material Output

Parameters:

Name	Type	Description	Default
surface	Shader	socket 'Surface' (id: Surface)	None
volume	VolumeShader	socket 'Volume' (id: Volume)	None
displacement	Vector	socket 'Displacement' (id: Displacement)	None
thickness	Float	socket 'Thickness' (id: Thickness)	None
is_active_output	bool	parameter is_active_output	True
target	Literal['All', 'EEVEE', 'Cycles']	parameter target	'ALL'

Returns:

Type	Description
None

Source code in core/generated/static_snd.py

@classmethod
def material_output(cls,
                surface: Shader = None,
                volume: VolumeShader = None,
                displacement: Vector = None,
                thickness: Float = None,
                is_active_output = True,
                target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL'):
    """ > Node Material Output

    Parameters
    ----------
    surface : Shader, optional
        socket 'Surface' (id: Surface)

    volume : VolumeShader, optional
        socket 'Volume' (id: Volume)

    displacement : Vector, optional
        socket 'Displacement' (id: Displacement)

    thickness : Float, optional
        socket 'Thickness' (id: Thickness)

    is_active_output : bool
        parameter `is_active_output`

    target : Literal['All', 'EEVEE', 'Cycles']
        parameter `target`


    Returns
    -------
    None
    """
    utils.check_enum_arg('Material Output', 'target', target, 'material_output', ('ALL', 'EEVEE', 'CYCLES'))
    node = Node('Material Output', {'Surface': surface, 'Volume': volume, 'Displacement': displacement, 'Thickness': thickness}, is_active_output=is_active_output, target=target)
    return node._out

math(value=None, value_1=None, value_2=None, operation='ADD', use_clamp=False) classmethod

Node Math

Parameters:

Name	Type	Description	Default
value	Float	socket 'Value' (id: Value)	None
value_1	Float	socket 'Value' (id: Value_001)	None
value_2	Float	socket 'Value' (id: Value_002)	None
operation	Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Power', 'Logarithm', 'Square Root', 'Inverse Square Root', 'Absolute', 'Exponent', 'Minimum', 'Maximum', 'Less Than', 'Greater Than', 'Sign', 'Compare', 'Smooth Minimum', 'Smooth Maximum', 'Round', 'Floor', 'Ceil', 'Truncate', 'Fraction', 'Truncated Modulo', 'Floored Modulo', 'Wrap', 'Snap', 'Ping-Pong', 'Sine', 'Cosine', 'Tangent', 'Arcsine', 'Arccosine', 'Arctangent', 'Arctan2', 'Hyperbolic Sine', 'Hyperbolic Cosine', 'Hyperbolic Tangent', 'To Radians', 'To Degrees']	parameter operation	'ADD'
use_clamp	bool	parameter use_clamp	False

Returns:

Type	Description
Float

Source code in core/generated/static_snd.py

@classmethod
def math(cls,
                value: Float = None,
                value_1: Float = None,
                value_2: Float = None,
                operation: Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'POWER', 'LOGARITHM', 'SQRT', 'INVERSE_SQRT', 'ABSOLUTE', 'EXPONENT', 'MINIMUM', 'MAXIMUM', 'LESS_THAN', 'GREATER_THAN', 'SIGN', 'COMPARE', 'SMOOTH_MIN', 'SMOOTH_MAX', 'ROUND', 'FLOOR', 'CEIL', 'TRUNC', 'FRACT', 'MODULO', 'FLOORED_MODULO', 'WRAP', 'SNAP', 'PINGPONG', 'SINE', 'COSINE', 'TANGENT', 'ARCSINE', 'ARCCOSINE', 'ARCTANGENT', 'ARCTAN2', 'SINH', 'COSH', 'TANH', 'RADIANS', 'DEGREES'] = 'ADD',
                use_clamp = False):
    """ > Node Math

    Parameters
    ----------
    value : Float, optional
        socket 'Value' (id: Value)

    value_1 : Float, optional
        socket 'Value' (id: Value_001)

    value_2 : Float, optional
        socket 'Value' (id: Value_002)

    operation : Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Power', 'Logarithm', 'Square Root', 'Inverse Square Root', 'Absolute', 'Exponent', 'Minimum', 'Maximum', 'Less Than', 'Greater Than', 'Sign', 'Compare', 'Smooth Minimum', 'Smooth Maximum', 'Round', 'Floor', 'Ceil', 'Truncate', 'Fraction', 'Truncated Modulo', 'Floored Modulo', 'Wrap', 'Snap', 'Ping-Pong', 'Sine', 'Cosine', 'Tangent', 'Arcsine', 'Arccosine', 'Arctangent', 'Arctan2', 'Hyperbolic Sine', 'Hyperbolic Cosine', 'Hyperbolic Tangent', 'To Radians', 'To Degrees']
        parameter `operation`

    use_clamp : bool
        parameter `use_clamp`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Math', 'operation', operation, 'math', ('ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'POWER', 'LOGARITHM', 'SQRT', 'INVERSE_SQRT', 'ABSOLUTE', 'EXPONENT', 'MINIMUM', 'MAXIMUM', 'LESS_THAN', 'GREATER_THAN', 'SIGN', 'COMPARE', 'SMOOTH_MIN', 'SMOOTH_MAX', 'ROUND', 'FLOOR', 'CEIL', 'TRUNC', 'FRACT', 'MODULO', 'FLOORED_MODULO', 'WRAP', 'SNAP', 'PINGPONG', 'SINE', 'COSINE', 'TANGENT', 'ARCSINE', 'ARCCOSINE', 'ARCTANGENT', 'ARCTAN2', 'SINH', 'COSH', 'TANH', 'RADIANS', 'DEGREES'))
    node = Node('Math', {'Value': value, 'Value_001': value_1, 'Value_002': value_2}, operation=operation, use_clamp=use_clamp)
    return node._out

menu_switch(named_sockets={}, menu=None, data_type='RGBA', **sockets) classmethod

Node Menu Switch

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
menu	Menu	Menu selection	None
data_type	Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Menu', 'Shader', 'Bundle', 'Closure']	parameter data_type	'RGBA'
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
Color	peer sockets: a_ (Boolean), b_ (Boolean)

Source code in core/generated/static_snd.py

@classmethod
def menu_switch(cls,
                named_sockets: dict = {},
                menu = None,
                data_type: Literal['FLOAT', 'INT', 'BOOLEAN', 'VECTOR', 'RGBA', 'MENU', 'SHADER', 'BUNDLE', 'CLOSURE'] = 'RGBA',
                **sockets):
    """ > Node Menu Switch

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    menu : Menu, optional
        Menu selection

    data_type : Literal['Float', 'Integer', 'Boolean', 'Vector', 'Color', 'Menu', 'Shader', 'Bundle', 'Closure']
        parameter `data_type`

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    Color
        peer sockets: a_ (Boolean), b_ (Boolean)

    """
    node = Node('Menu Switch', {'Menu': menu, **named_sockets}, data_type=data_type, **sockets)
    return node._out

metallic_bsdf(base_color=None, edge_tint=None, ior=None, extinction=None, roughness=None, anisotropy=None, rotation=None, normal=None, tangent=None, weight=None, thin_film_thickness=None, thin_film_ior=None, distribution='MULTI_GGX', fresnel_type='F82') classmethod

Node Metallic BSDF

Parameters:

Name	Type	Description	Default
base_color	Color	socket 'Base Color' (id: Base Color)	None
edge_tint	Color	socket 'Edge Tint' (id: Edge Tint)	None
ior	Vector	socket 'IOR' (id: IOR)	None
extinction	Vector	socket 'Extinction' (id: Extinction)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
anisotropy	Float	socket 'Anisotropy' (id: Anisotropy)	None
rotation	Float	socket 'Rotation' (id: Rotation)	None
normal	Vector	socket 'Normal' (id: Normal)	None
tangent	Vector	socket 'Tangent' (id: Tangent)	None
weight	Float	socket 'Weight' (id: Weight)	None
thin_film_thickness	Float	socket 'Thin Film Thickness' (id: Thin Film Thickness)	None
thin_film_ior	Float	socket 'Thin Film IOR' (id: Thin Film IOR)	None
distribution	Literal['Beckmann', 'GGX', 'Multiscatter GGX']	parameter distribution	'MULTI_GGX'
fresnel_type	Literal['Physical Conductor', 'F82 Tint']	parameter fresnel_type	'F82'

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def metallic_bsdf(cls,
                base_color: Color = None,
                edge_tint: Color = None,
                ior: Vector = None,
                extinction: Vector = None,
                roughness: Float = None,
                anisotropy: Float = None,
                rotation: Float = None,
                normal: Vector = None,
                tangent: Vector = None,
                weight: Float = None,
                thin_film_thickness: Float = None,
                thin_film_ior: Float = None,
                distribution: Literal['BECKMANN', 'GGX', 'MULTI_GGX'] = 'MULTI_GGX',
                fresnel_type: Literal['PHYSICAL_CONDUCTOR', 'F82'] = 'F82'):
    """ > Node Metallic BSDF

    Parameters
    ----------
    base_color : Color, optional
        socket 'Base Color' (id: Base Color)

    edge_tint : Color, optional
        socket 'Edge Tint' (id: Edge Tint)

    ior : Vector, optional
        socket 'IOR' (id: IOR)

    extinction : Vector, optional
        socket 'Extinction' (id: Extinction)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    anisotropy : Float, optional
        socket 'Anisotropy' (id: Anisotropy)

    rotation : Float, optional
        socket 'Rotation' (id: Rotation)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    tangent : Vector, optional
        socket 'Tangent' (id: Tangent)

    weight : Float, optional
        socket 'Weight' (id: Weight)

    thin_film_thickness : Float, optional
        socket 'Thin Film Thickness' (id: Thin Film Thickness)

    thin_film_ior : Float, optional
        socket 'Thin Film IOR' (id: Thin Film IOR)

    distribution : Literal['Beckmann', 'GGX', 'Multiscatter GGX']
        parameter `distribution`

    fresnel_type : Literal['Physical Conductor', 'F82 Tint']
        parameter `fresnel_type`


    Returns
    -------
    Shader
    """
    utils.check_enum_arg('Metallic BSDF', 'distribution', distribution, 'metallic_bsdf', ('BECKMANN', 'GGX', 'MULTI_GGX'))
    utils.check_enum_arg('Metallic BSDF', 'fresnel_type', fresnel_type, 'metallic_bsdf', ('PHYSICAL_CONDUCTOR', 'F82'))
    node = Node('Metallic BSDF', {'Base Color': base_color, 'Edge Tint': edge_tint, 'IOR': ior, 'Extinction': extinction, 'Roughness': roughness, 'Anisotropy': anisotropy, 'Rotation': rotation, 'Normal': normal, 'Tangent': tangent, 'Weight': weight, 'Thin Film Thickness': thin_film_thickness, 'Thin Film IOR': thin_film_ior}, distribution=distribution, fresnel_type=fresnel_type)
    return node._out

mix(a=None, b=None, a_1=None, b_1=None, a_2=None, b_2=None, a_3=None, b_3=None, factor=None, blend_type='MIX', clamp_factor=True, clamp_result=False, data_type='FLOAT', factor_mode='UNIFORM') classmethod

Node Mix

Parameters:

Name	Type	Description	Default
a	Float	socket 'A' (id: A_Float)	None
b	Float	socket 'B' (id: B_Float)	None
a_1	Vector	socket 'A' (id: A_Vector)	None
b_1	Vector	socket 'B' (id: B_Vector)	None
a_2	Color	socket 'A' (id: A_Color)	None
b_2	Color	socket 'B' (id: B_Color)	None
a_3	Rotation	socket 'A' (id: A_Rotation)	None
b_3	Rotation	socket 'B' (id: B_Rotation)	None
factor	Vector	socket 'Factor' (id: Factor_Vector)	None
blend_type	Literal['Mix', 'Darken', 'Multiply', 'Color Burn', 'Lighten', 'Screen', 'Color Dodge', 'Add', 'Overlay', 'Soft Light', 'Linear Light', 'Difference', 'Exclusion', 'Subtract', 'Divide', 'Hue', 'Saturation', 'Color', 'Value']	parameter blend_type	'MIX'
clamp_factor	bool	parameter clamp_factor	True
clamp_result	bool	parameter clamp_result	False
data_type	Literal['Float', 'Vector', 'Color']	parameter data_type	'FLOAT'
factor_mode	Literal['Uniform', 'Non-Uniform']	parameter factor_mode	'UNIFORM'

Returns:

Type	Description
Float

Source code in core/generated/static_snd.py

@classmethod
def mix(cls,
                a: Float = None,
                b: Float = None,
                a_1: Vector = None,
                b_1: Vector = None,
                a_2: Color = None,
                b_2: Color = None,
                a_3: Rotation = None,
                b_3: Rotation = None,
                factor: Vector = None,
                blend_type: Literal['MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'] = 'MIX',
                clamp_factor = True,
                clamp_result = False,
                data_type: Literal['FLOAT', 'VECTOR', 'RGBA'] = 'FLOAT',
                factor_mode: Literal['UNIFORM', 'NON_UNIFORM'] = 'UNIFORM'):
    """ > Node Mix

    Parameters
    ----------
    a : Float, optional
        socket 'A' (id: A_Float)

    b : Float, optional
        socket 'B' (id: B_Float)

    a_1 : Vector, optional
        socket 'A' (id: A_Vector)

    b_1 : Vector, optional
        socket 'B' (id: B_Vector)

    a_2 : Color, optional
        socket 'A' (id: A_Color)

    b_2 : Color, optional
        socket 'B' (id: B_Color)

    a_3 : Rotation, optional
        socket 'A' (id: A_Rotation)

    b_3 : Rotation, optional
        socket 'B' (id: B_Rotation)

    factor : Vector, optional
        socket 'Factor' (id: Factor_Vector)

    blend_type : Literal['Mix', 'Darken', 'Multiply', 'Color Burn', 'Lighten', 'Screen', 'Color Dodge', 'Add', 'Overlay', 'Soft Light', 'Linear Light', 'Difference', 'Exclusion', 'Subtract', 'Divide', 'Hue', 'Saturation', 'Color', 'Value']
        parameter `blend_type`

    clamp_factor : bool
        parameter `clamp_factor`

    clamp_result : bool
        parameter `clamp_result`

    data_type : Literal['Float', 'Vector', 'Color']
        parameter `data_type`

    factor_mode : Literal['Uniform', 'Non-Uniform']
        parameter `factor_mode`


    Returns
    -------
    Float
    """
    utils.check_enum_arg('Mix', 'blend_type', blend_type, 'mix', ('MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD', 'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE', 'HUE', 'SATURATION', 'COLOR', 'VALUE'))
    utils.check_enum_arg('Mix', 'factor_mode', factor_mode, 'mix', ('UNIFORM', 'NON_UNIFORM'))
    node = Node('Mix', {'A_Float': a, 'B_Float': b, 'A_Vector': a_1, 'B_Vector': b_1, 'A_Color': a_2, 'B_Color': b_2, 'A_Rotation': a_3, 'B_Rotation': b_3, 'Factor_Vector': factor}, blend_type=blend_type, clamp_factor=clamp_factor, clamp_result=clamp_result, data_type=data_type, factor_mode=factor_mode)
    return node._out

mix_shader(shader=None, shader_1=None, factor=None) classmethod

Node Mix Shader

Parameters:

Name	Type	Description	Default
shader	Shader	socket 'Shader' (id: Shader)	None
shader_1	Shader	socket 'Shader' (id: Shader_001)	None
factor	Float	socket 'Factor' (id: Fac)	None

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def mix_shader(cls, shader: Shader = None, shader_1: Shader = None, factor: Float = None):
    """ > Node Mix Shader

    Parameters
    ----------
    shader : Shader, optional
        socket 'Shader' (id: Shader)

    shader_1 : Shader, optional
        socket 'Shader' (id: Shader_001)

    factor : Float, optional
        socket 'Factor' (id: Fac)


    Returns
    -------
    Shader
    """
    node = Node('Mix Shader', {'Shader': shader, 'Shader_001': shader_1, 'Fac': factor})
    return node._out

noise_texture(vector=None, w=None, scale=None, detail=None, roughness=None, lacunarity=None, offset=None, gain=None, distortion=None, noise_dimensions='3D', noise_type='FBM', normalize=True) classmethod

Node Noise Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
w	Float	socket 'W' (id: W)	None
scale	Float	socket 'Scale' (id: Scale)	None
detail	Float	socket 'Detail' (id: Detail)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
lacunarity	Float	socket 'Lacunarity' (id: Lacunarity)	None
offset	Float	socket 'Offset' (id: Offset)	None
gain	Float	socket 'Gain' (id: Gain)	None
distortion	Float	socket 'Distortion' (id: Distortion)	None
noise_dimensions	Literal['1D', '2D', '3D', '4D']	parameter noise_dimensions	'3D'
noise_type	Literal['Multifractal', 'Ridged Multifractal', 'Hybrid Multifractal', 'fBM', 'Hetero Terrain']	parameter noise_type	'FBM'
normalize	bool	parameter normalize	True

Returns:

Type	Description
Float	peer sockets: color_ (Color)

Source code in core/generated/static_snd.py

@classmethod
def noise_texture(cls,
                vector: Vector = None,
                w: Float = None,
                scale: Float = None,
                detail: Float = None,
                roughness: Float = None,
                lacunarity: Float = None,
                offset: Float = None,
                gain: Float = None,
                distortion: Float = None,
                noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D',
                noise_type: Literal['MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN'] = 'FBM',
                normalize = True):
    """ > Node Noise Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    w : Float, optional
        socket 'W' (id: W)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    detail : Float, optional
        socket 'Detail' (id: Detail)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    lacunarity : Float, optional
        socket 'Lacunarity' (id: Lacunarity)

    offset : Float, optional
        socket 'Offset' (id: Offset)

    gain : Float, optional
        socket 'Gain' (id: Gain)

    distortion : Float, optional
        socket 'Distortion' (id: Distortion)

    noise_dimensions : Literal['1D', '2D', '3D', '4D']
        parameter `noise_dimensions`

    noise_type : Literal['Multifractal', 'Ridged Multifractal', 'Hybrid Multifractal', 'fBM', 'Hetero Terrain']
        parameter `noise_type`

    normalize : bool
        parameter `normalize`


    Returns
    -------
    Float
        peer sockets: color_ (Color)

    """
    utils.check_enum_arg('Noise Texture', 'noise_dimensions', noise_dimensions, 'noise_texture', ('1D', '2D', '3D', '4D'))
    utils.check_enum_arg('Noise Texture', 'noise_type', noise_type, 'noise_texture', ('MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN'))
    node = Node('Noise Texture', {'Vector': vector, 'W': w, 'Scale': scale, 'Detail': detail, 'Roughness': roughness, 'Lacunarity': lacunarity, 'Offset': offset, 'Gain': gain, 'Distortion': distortion}, noise_dimensions=noise_dimensions, noise_type=noise_type, normalize=normalize)
    return node._out

normal(normal=None) classmethod

Node Normal

Parameters:

Name	Type	Description	Default
normal	Vector	socket 'Normal' (id: Normal)	None

Returns:

Type	Description
Vector	peer sockets: dot_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def normal(cls, normal: Vector = None):
    """ > Node Normal

    Parameters
    ----------
    normal : Vector, optional
        socket 'Normal' (id: Normal)


    Returns
    -------
    Vector
        peer sockets: dot_ (Float)

    """
    node = Node('Normal', {'Normal': normal})
    return node._out

normal_map(strength=None, color=None, base='DISPLACED', convention='OPENGL', space='TANGENT', uv_map='') classmethod

Node Normal Map

Parameters:

Name	Type	Description	Default
strength	Float	socket 'Strength' (id: Strength)	None
color	Color	socket 'Color' (id: Color)	None
base	Literal['Original Base', 'Displaced Base']	parameter base	'DISPLACED'
convention	Literal['OpenGL', 'DirectX']	parameter convention	'OPENGL'
space	Literal['Tangent Space', 'Object Space', 'World Space', 'Blender Object Space', 'Blender World Space']	parameter space	'TANGENT'
uv_map	str	parameter uv_map	''

Returns:

Type	Description
Vector

Source code in core/generated/static_snd.py

@classmethod
def normal_map(cls,
                strength: Float = None,
                color: Color = None,
                base: Literal['ORIGINAL', 'DISPLACED'] = 'DISPLACED',
                convention: Literal['OPENGL', 'DIRECTX'] = 'OPENGL',
                space: Literal['TANGENT', 'OBJECT', 'WORLD', 'BLENDER_OBJECT', 'BLENDER_WORLD'] = 'TANGENT',
                uv_map = ''):
    """ > Node Normal Map

    Parameters
    ----------
    strength : Float, optional
        socket 'Strength' (id: Strength)

    color : Color, optional
        socket 'Color' (id: Color)

    base : Literal['Original Base', 'Displaced Base']
        parameter `base`

    convention : Literal['OpenGL', 'DirectX']
        parameter `convention`

    space : Literal['Tangent Space', 'Object Space', 'World Space', 'Blender Object Space', 'Blender World Space']
        parameter `space`

    uv_map : str
        parameter `uv_map`


    Returns
    -------
    Vector
    """
    utils.check_enum_arg('Normal Map', 'base', base, 'normal_map', ('ORIGINAL', 'DISPLACED'))
    utils.check_enum_arg('Normal Map', 'convention', convention, 'normal_map', ('OPENGL', 'DIRECTX'))
    utils.check_enum_arg('Normal Map', 'space', space, 'normal_map', ('TANGENT', 'OBJECT', 'WORLD', 'BLENDER_OBJECT', 'BLENDER_WORLD'))
    node = Node('Normal Map', {'Strength': strength, 'Color': color}, base=base, convention=convention, space=space, uv_map=uv_map)
    return node._out

object_info() classmethod

Node Object Info

Returns:

Type	Description
Vector	peer sockets: color_ (Color), alpha_ (Float), object_index_ (Float), material_index_ (Float), random_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def object_info(cls):
    """ > Node Object Info

    Returns
    -------
    Vector
        peer sockets: color_ (Color), alpha_ (Float), object_index_ (Float), material_index_ (Float), random_ (Float)

    """
    node = Node('Object Info', )
    return node

particle_info() classmethod

Node Particle Info

Returns:

Type	Description
Float	peer sockets: random_ (Float), age_ (Float), lifetime_ (Float), location_ (Vector), size_ (Float), velocity_ (Vector), angular_velocity_ (Vector)

Source code in core/generated/static_snd.py

@classmethod
def particle_info(cls):
    """ > Node Particle Info

    Returns
    -------
    Float
        peer sockets: random_ (Float), age_ (Float), lifetime_ (Float), location_ (Vector), size_ (Float), velocity_ (Vector), angular_velocity_ (Vector)

    """
    node = Node('Particle Info', )
    return node

point_info() classmethod

Node Point Info

Returns:

Type	Description
Vector	peer sockets: radius_ (Float), random_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def point_info(cls):
    """ > Node Point Info

    Returns
    -------
    Vector
        peer sockets: radius_ (Float), random_ (Float)

    """
    node = Node('Point Info', )
    return node

principled_bsdf(base_color=None, metallic=None, roughness=None, ior=None, alpha=None, normal=None, weight=None, diffuse_roughness=None, subsurface_weight=None, subsurface_radius=None, subsurface_scale=None, subsurface_ior=None, subsurface_anisotropy=None, specular_ior_level=None, specular_tint=None, anisotropic=None, anisotropic_rotation=None, tangent=None, transmission_weight=None, coat_weight=None, coat_roughness=None, coat_ior=None, coat_tint=None, coat_normal=None, sheen_weight=None, sheen_roughness=None, sheen_tint=None, emission_color=None, emission_strength=None, thin_film_thickness=None, thin_film_ior=None, distribution='MULTI_GGX', subsurface_method='RANDOM_WALK') classmethod

Node Principled BSDF

Parameters:

Name	Type	Description	Default
base_color	Color	socket 'Base Color' (id: Base Color)	None
metallic	Float	socket 'Metallic' (id: Metallic)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
ior	Float	socket 'IOR' (id: IOR)	None
alpha	Float	socket 'Alpha' (id: Alpha)	None
normal	Vector	socket 'Normal' (id: Normal)	None
weight	Float	socket 'Weight' (id: Weight)	None
diffuse_roughness	Float	socket 'Diffuse Roughness' (id: Diffuse Roughness)	None
subsurface_weight	Float	socket 'Subsurface Weight' (id: Subsurface Weight)	None
subsurface_radius	Vector	socket 'Subsurface Radius' (id: Subsurface Radius)	None
subsurface_scale	Float	socket 'Subsurface Scale' (id: Subsurface Scale)	None
subsurface_ior	Float	socket 'Subsurface IOR' (id: Subsurface IOR)	None
subsurface_anisotropy	Float	socket 'Subsurface Anisotropy' (id: Subsurface Anisotropy)	None
specular_ior_level	Float	socket 'Specular IOR Level' (id: Specular IOR Level)	None
specular_tint	Color	socket 'Specular Tint' (id: Specular Tint)	None
anisotropic	Float	socket 'Anisotropic' (id: Anisotropic)	None
anisotropic_rotation	Float	socket 'Anisotropic Rotation' (id: Anisotropic Rotation)	None
tangent	Vector	socket 'Tangent' (id: Tangent)	None
transmission_weight	Float	socket 'Transmission Weight' (id: Transmission Weight)	None
coat_weight	Float	socket 'Coat Weight' (id: Coat Weight)	None
coat_roughness	Float	socket 'Coat Roughness' (id: Coat Roughness)	None
coat_ior	Float	socket 'Coat IOR' (id: Coat IOR)	None
coat_tint	Color	socket 'Coat Tint' (id: Coat Tint)	None
coat_normal	Vector	socket 'Coat Normal' (id: Coat Normal)	None
sheen_weight	Float	socket 'Sheen Weight' (id: Sheen Weight)	None
sheen_roughness	Float	socket 'Sheen Roughness' (id: Sheen Roughness)	None
sheen_tint	Color	socket 'Sheen Tint' (id: Sheen Tint)	None
emission_color	Color	socket 'Emission Color' (id: Emission Color)	None
emission_strength	Float	socket 'Emission Strength' (id: Emission Strength)	None
thin_film_thickness	Float	socket 'Thin Film Thickness' (id: Thin Film Thickness)	None
thin_film_ior	Float	socket 'Thin Film IOR' (id: Thin Film IOR)	None
distribution	Literal['GGX', 'Multiscatter GGX']	parameter distribution	'MULTI_GGX'
subsurface_method	Literal['Christensen-Burley', 'Random Walk', 'Random Walk (Skin)']	parameter subsurface_method	'RANDOM_WALK'

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def principled_bsdf(cls,
                base_color: Color = None,
                metallic: Float = None,
                roughness: Float = None,
                ior: Float = None,
                alpha: Float = None,
                normal: Vector = None,
                weight: Float = None,
                diffuse_roughness: Float = None,
                subsurface_weight: Float = None,
                subsurface_radius: Vector = None,
                subsurface_scale: Float = None,
                subsurface_ior: Float = None,
                subsurface_anisotropy: Float = None,
                specular_ior_level: Float = None,
                specular_tint: Color = None,
                anisotropic: Float = None,
                anisotropic_rotation: Float = None,
                tangent: Vector = None,
                transmission_weight: Float = None,
                coat_weight: Float = None,
                coat_roughness: Float = None,
                coat_ior: Float = None,
                coat_tint: Color = None,
                coat_normal: Vector = None,
                sheen_weight: Float = None,
                sheen_roughness: Float = None,
                sheen_tint: Color = None,
                emission_color: Color = None,
                emission_strength: Float = None,
                thin_film_thickness: Float = None,
                thin_film_ior: Float = None,
                distribution: Literal['GGX', 'MULTI_GGX'] = 'MULTI_GGX',
                subsurface_method: Literal['BURLEY', 'RANDOM_WALK', 'RANDOM_WALK_SKIN'] = 'RANDOM_WALK'):
    """ > Node Principled BSDF

    Parameters
    ----------
    base_color : Color, optional
        socket 'Base Color' (id: Base Color)

    metallic : Float, optional
        socket 'Metallic' (id: Metallic)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    ior : Float, optional
        socket 'IOR' (id: IOR)

    alpha : Float, optional
        socket 'Alpha' (id: Alpha)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    weight : Float, optional
        socket 'Weight' (id: Weight)

    diffuse_roughness : Float, optional
        socket 'Diffuse Roughness' (id: Diffuse Roughness)

    subsurface_weight : Float, optional
        socket 'Subsurface Weight' (id: Subsurface Weight)

    subsurface_radius : Vector, optional
        socket 'Subsurface Radius' (id: Subsurface Radius)

    subsurface_scale : Float, optional
        socket 'Subsurface Scale' (id: Subsurface Scale)

    subsurface_ior : Float, optional
        socket 'Subsurface IOR' (id: Subsurface IOR)

    subsurface_anisotropy : Float, optional
        socket 'Subsurface Anisotropy' (id: Subsurface Anisotropy)

    specular_ior_level : Float, optional
        socket 'Specular IOR Level' (id: Specular IOR Level)

    specular_tint : Color, optional
        socket 'Specular Tint' (id: Specular Tint)

    anisotropic : Float, optional
        socket 'Anisotropic' (id: Anisotropic)

    anisotropic_rotation : Float, optional
        socket 'Anisotropic Rotation' (id: Anisotropic Rotation)

    tangent : Vector, optional
        socket 'Tangent' (id: Tangent)

    transmission_weight : Float, optional
        socket 'Transmission Weight' (id: Transmission Weight)

    coat_weight : Float, optional
        socket 'Coat Weight' (id: Coat Weight)

    coat_roughness : Float, optional
        socket 'Coat Roughness' (id: Coat Roughness)

    coat_ior : Float, optional
        socket 'Coat IOR' (id: Coat IOR)

    coat_tint : Color, optional
        socket 'Coat Tint' (id: Coat Tint)

    coat_normal : Vector, optional
        socket 'Coat Normal' (id: Coat Normal)

    sheen_weight : Float, optional
        socket 'Sheen Weight' (id: Sheen Weight)

    sheen_roughness : Float, optional
        socket 'Sheen Roughness' (id: Sheen Roughness)

    sheen_tint : Color, optional
        socket 'Sheen Tint' (id: Sheen Tint)

    emission_color : Color, optional
        socket 'Emission Color' (id: Emission Color)

    emission_strength : Float, optional
        socket 'Emission Strength' (id: Emission Strength)

    thin_film_thickness : Float, optional
        socket 'Thin Film Thickness' (id: Thin Film Thickness)

    thin_film_ior : Float, optional
        socket 'Thin Film IOR' (id: Thin Film IOR)

    distribution : Literal['GGX', 'Multiscatter GGX']
        parameter `distribution`

    subsurface_method : Literal['Christensen-Burley', 'Random Walk', 'Random Walk (Skin)']
        parameter `subsurface_method`


    Returns
    -------
    Shader
    """
    utils.check_enum_arg('Principled BSDF', 'distribution', distribution, 'principled_bsdf', ('GGX', 'MULTI_GGX'))
    utils.check_enum_arg('Principled BSDF', 'subsurface_method', subsurface_method, 'principled_bsdf', ('BURLEY', 'RANDOM_WALK', 'RANDOM_WALK_SKIN'))
    node = Node('Principled BSDF', {'Base Color': base_color, 'Metallic': metallic, 'Roughness': roughness, 'IOR': ior, 'Alpha': alpha, 'Normal': normal, 'Weight': weight, 'Diffuse Roughness': diffuse_roughness, 'Subsurface Weight': subsurface_weight, 'Subsurface Radius': subsurface_radius, 'Subsurface Scale': subsurface_scale, 'Subsurface IOR': subsurface_ior, 'Subsurface Anisotropy': subsurface_anisotropy, 'Specular IOR Level': specular_ior_level, 'Specular Tint': specular_tint, 'Anisotropic': anisotropic, 'Anisotropic Rotation': anisotropic_rotation, 'Tangent': tangent, 'Transmission Weight': transmission_weight, 'Coat Weight': coat_weight, 'Coat Roughness': coat_roughness, 'Coat IOR': coat_ior, 'Coat Tint': coat_tint, 'Coat Normal': coat_normal, 'Sheen Weight': sheen_weight, 'Sheen Roughness': sheen_roughness, 'Sheen Tint': sheen_tint, 'Emission Color': emission_color, 'Emission Strength': emission_strength, 'Thin Film Thickness': thin_film_thickness, 'Thin Film IOR': thin_film_ior}, distribution=distribution, subsurface_method=subsurface_method)
    return node._out

principled_hair_bsdf(color=None, melanin=None, melanin_redness=None, tint=None, absorption_coefficient=None, aspect_ratio=None, roughness=None, radial_roughness=None, coat=None, ior=None, offset=None, random_color=None, random_roughness=None, random=None, weight=None, reflection=None, transmission=None, secondary_reflection=None, model='CHIANG', parametrization='COLOR') classmethod

Node Principled Hair BSDF

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
melanin	Float	socket 'Melanin' (id: Melanin)	None
melanin_redness	Float	socket 'Melanin Redness' (id: Melanin Redness)	None
tint	Color	socket 'Tint' (id: Tint)	None
absorption_coefficient	Vector	socket 'Absorption Coefficient' (id: Absorption Coefficient)	None
aspect_ratio	Float	socket 'Aspect Ratio' (id: Aspect Ratio)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
radial_roughness	Float	socket 'Radial Roughness' (id: Radial Roughness)	None
coat	Float	socket 'Coat' (id: Coat)	None
ior	Float	socket 'IOR' (id: IOR)	None
offset	Float	socket 'Offset' (id: Offset)	None
random_color	Float	socket 'Random Color' (id: Random Color)	None
random_roughness	Float	socket 'Random Roughness' (id: Random Roughness)	None
random	Float	socket 'Random' (id: Random)	None
weight	Float	socket 'Weight' (id: Weight)	None
reflection	Float	socket 'Reflection' (id: R lobe)	None
transmission	Float	socket 'Transmission' (id: TT lobe)	None
secondary_reflection	Float	socket 'Secondary Reflection' (id: TRT lobe)	None
model	Literal['Chiang', 'Huang']	parameter model	'CHIANG'
parametrization	Literal['Absorption Coefficient', 'Melanin Concentration', 'Direct Coloring']	parameter parametrization	'COLOR'

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def principled_hair_bsdf(cls,
                color: Color = None,
                melanin: Float = None,
                melanin_redness: Float = None,
                tint: Color = None,
                absorption_coefficient: Vector = None,
                aspect_ratio: Float = None,
                roughness: Float = None,
                radial_roughness: Float = None,
                coat: Float = None,
                ior: Float = None,
                offset: Float = None,
                random_color: Float = None,
                random_roughness: Float = None,
                random: Float = None,
                weight: Float = None,
                reflection: Float = None,
                transmission: Float = None,
                secondary_reflection: Float = None,
                model: Literal['CHIANG', 'HUANG'] = 'CHIANG',
                parametrization: Literal['ABSORPTION', 'MELANIN', 'COLOR'] = 'COLOR'):
    """ > Node Principled Hair BSDF

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    melanin : Float, optional
        socket 'Melanin' (id: Melanin)

    melanin_redness : Float, optional
        socket 'Melanin Redness' (id: Melanin Redness)

    tint : Color, optional
        socket 'Tint' (id: Tint)

    absorption_coefficient : Vector, optional
        socket 'Absorption Coefficient' (id: Absorption Coefficient)

    aspect_ratio : Float, optional
        socket 'Aspect Ratio' (id: Aspect Ratio)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    radial_roughness : Float, optional
        socket 'Radial Roughness' (id: Radial Roughness)

    coat : Float, optional
        socket 'Coat' (id: Coat)

    ior : Float, optional
        socket 'IOR' (id: IOR)

    offset : Float, optional
        socket 'Offset' (id: Offset)

    random_color : Float, optional
        socket 'Random Color' (id: Random Color)

    random_roughness : Float, optional
        socket 'Random Roughness' (id: Random Roughness)

    random : Float, optional
        socket 'Random' (id: Random)

    weight : Float, optional
        socket 'Weight' (id: Weight)

    reflection : Float, optional
        socket 'Reflection' (id: R lobe)

    transmission : Float, optional
        socket 'Transmission' (id: TT lobe)

    secondary_reflection : Float, optional
        socket 'Secondary Reflection' (id: TRT lobe)

    model : Literal['Chiang', 'Huang']
        parameter `model`

    parametrization : Literal['Absorption Coefficient', 'Melanin Concentration', 'Direct Coloring']
        parameter `parametrization`


    Returns
    -------
    Shader
    """
    utils.check_enum_arg('Principled Hair BSDF', 'model', model, 'principled_hair_bsdf', ('CHIANG', 'HUANG'))
    utils.check_enum_arg('Principled Hair BSDF', 'parametrization', parametrization, 'principled_hair_bsdf', ('ABSORPTION', 'MELANIN', 'COLOR'))
    node = Node('Principled Hair BSDF', {'Color': color, 'Melanin': melanin, 'Melanin Redness': melanin_redness, 'Tint': tint, 'Absorption Coefficient': absorption_coefficient, 'Aspect Ratio': aspect_ratio, 'Roughness': roughness, 'Radial Roughness': radial_roughness, 'Coat': coat, 'IOR': ior, 'Offset': offset, 'Random Color': random_color, 'Random Roughness': random_roughness, 'Random': random, 'Weight': weight, 'R lobe': reflection, 'TT lobe': transmission, 'TRT lobe': secondary_reflection}, model=model, parametrization=parametrization)
    return node._out

principled_volume(color=None, color_attribute=None, density=None, density_attribute=None, anisotropy=None, absorption_color=None, emission_strength=None, emission_color=None, blackbody_intensity=None, blackbody_tint=None, temperature=None, temperature_attribute=None, weight=None) classmethod

Node Principled Volume

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
color_attribute	String	socket 'Color Attribute' (id: Color Attribute)	None
density	Float	socket 'Density' (id: Density)	None
density_attribute	String	socket 'Density Attribute' (id: Density Attribute)	None
anisotropy	Float	socket 'Anisotropy' (id: Anisotropy)	None
absorption_color	Color	socket 'Absorption Color' (id: Absorption Color)	None
emission_strength	Float	socket 'Emission Strength' (id: Emission Strength)	None
emission_color	Color	socket 'Emission Color' (id: Emission Color)	None
blackbody_intensity	Float	socket 'Blackbody Intensity' (id: Blackbody Intensity)	None
blackbody_tint	Color	socket 'Blackbody Tint' (id: Blackbody Tint)	None
temperature	Float	socket 'Temperature' (id: Temperature)	None
temperature_attribute	String	socket 'Temperature Attribute' (id: Temperature Attribute)	None
weight	Float	socket 'Weight' (id: Weight)	None

Returns:

Type	Description
VolumeShader

Source code in core/generated/static_snd.py

@classmethod
def principled_volume(cls,
                color: Color = None,
                color_attribute: String = None,
                density: Float = None,
                density_attribute: String = None,
                anisotropy: Float = None,
                absorption_color: Color = None,
                emission_strength: Float = None,
                emission_color: Color = None,
                blackbody_intensity: Float = None,
                blackbody_tint: Color = None,
                temperature: Float = None,
                temperature_attribute: String = None,
                weight: Float = None):
    """ > Node Principled Volume

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    color_attribute : String, optional
        socket 'Color Attribute' (id: Color Attribute)

    density : Float, optional
        socket 'Density' (id: Density)

    density_attribute : String, optional
        socket 'Density Attribute' (id: Density Attribute)

    anisotropy : Float, optional
        socket 'Anisotropy' (id: Anisotropy)

    absorption_color : Color, optional
        socket 'Absorption Color' (id: Absorption Color)

    emission_strength : Float, optional
        socket 'Emission Strength' (id: Emission Strength)

    emission_color : Color, optional
        socket 'Emission Color' (id: Emission Color)

    blackbody_intensity : Float, optional
        socket 'Blackbody Intensity' (id: Blackbody Intensity)

    blackbody_tint : Color, optional
        socket 'Blackbody Tint' (id: Blackbody Tint)

    temperature : Float, optional
        socket 'Temperature' (id: Temperature)

    temperature_attribute : String, optional
        socket 'Temperature Attribute' (id: Temperature Attribute)

    weight : Float, optional
        socket 'Weight' (id: Weight)


    Returns
    -------
    VolumeShader
    """
    node = Node('Principled Volume', {'Color': color, 'Color Attribute': color_attribute, 'Density': density, 'Density Attribute': density_attribute, 'Anisotropy': anisotropy, 'Absorption Color': absorption_color, 'Emission Strength': emission_strength, 'Emission Color': emission_color, 'Blackbody Intensity': blackbody_intensity, 'Blackbody Tint': blackbody_tint, 'Temperature': temperature, 'Temperature Attribute': temperature_attribute, 'Weight': weight})
    return node._out

radial_tiling(vector=None, sides=None, roundness=None, normalize=False) classmethod

Node Radial Tiling

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
sides	Float	socket 'Sides' (id: Sides)	None
roundness	Float	socket 'Roundness' (id: Roundness)	None
normalize	bool	parameter normalize	False

Returns:

Type	Description
Vector	peer sockets: segment_id_ (Float), segment_width_ (Float), segment_rotation_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def radial_tiling(cls,
                vector: Vector = None,
                sides: Float = None,
                roundness: Float = None,
                normalize = False):
    """ > Node Radial Tiling

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    sides : Float, optional
        socket 'Sides' (id: Sides)

    roundness : Float, optional
        socket 'Roundness' (id: Roundness)

    normalize : bool
        parameter `normalize`


    Returns
    -------
    Vector
        peer sockets: segment_id_ (Float), segment_width_ (Float), segment_rotation_ (Float)

    """
    node = Node('Radial Tiling', {'Vector': vector, 'Sides': sides, 'Roundness': roundness}, normalize=normalize)
    return node._out

ray_portal_bsdf(color=None, position=None, direction=None, weight=None) classmethod

Node Ray Portal BSDF

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
position	Vector	socket 'Position' (id: Position)	None
direction	Vector	socket 'Direction' (id: Direction)	None
weight	Float	socket 'Weight' (id: Weight)	None

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def ray_portal_bsdf(cls,
                color: Color = None,
                position: Vector = None,
                direction: Vector = None,
                weight: Float = None):
    """ > Node Ray Portal BSDF

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    position : Vector, optional
        socket 'Position' (id: Position)

    direction : Vector, optional
        socket 'Direction' (id: Direction)

    weight : Float, optional
        socket 'Weight' (id: Weight)


    Returns
    -------
    Shader
    """
    node = Node('Ray Portal BSDF', {'Color': color, 'Position': position, 'Direction': direction, 'Weight': weight})
    return node._out

raycast(position=None, direction=None, length=None, only_local=False) classmethod

Node Raycast

Parameters:

Name	Type	Description	Default
position	Vector	socket 'Position' (id: Position)	None
direction	Vector	socket 'Direction' (id: Direction)	None
length	Float	socket 'Length' (id: Length)	None
only_local	bool	parameter only_local	False

Returns:

Type	Description
Float	peer sockets: self_hit_ (Float), hit_distance_ (Float), hit_position_ (Vector), hit_normal_ (Vector)

Source code in core/generated/static_snd.py

@classmethod
def raycast(cls,
                position: Vector = None,
                direction: Vector = None,
                length: Float = None,
                only_local = False):
    """ > Node Raycast

    Parameters
    ----------
    position : Vector, optional
        socket 'Position' (id: Position)

    direction : Vector, optional
        socket 'Direction' (id: Direction)

    length : Float, optional
        socket 'Length' (id: Length)

    only_local : bool
        parameter `only_local`


    Returns
    -------
    Float
        peer sockets: self_hit_ (Float), hit_distance_ (Float), hit_position_ (Vector), hit_normal_ (Vector)

    """
    node = Node('Raycast', {'Position': position, 'Direction': direction, 'Length': length}, only_local=only_local)
    return node._out

refraction_bsdf(color=None, roughness=None, ior=None, normal=None, weight=None, distribution='BECKMANN') classmethod

Node Refraction BSDF

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
ior	Float	socket 'IOR' (id: IOR)	None
normal	Vector	socket 'Normal' (id: Normal)	None
weight	Float	socket 'Weight' (id: Weight)	None
distribution	Literal['Beckmann', 'GGX']	parameter distribution	'BECKMANN'

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def refraction_bsdf(cls,
                color: Color = None,
                roughness: Float = None,
                ior: Float = None,
                normal: Vector = None,
                weight: Float = None,
                distribution: Literal['BECKMANN', 'GGX'] = 'BECKMANN'):
    """ > Node Refraction BSDF

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    ior : Float, optional
        socket 'IOR' (id: IOR)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    weight : Float, optional
        socket 'Weight' (id: Weight)

    distribution : Literal['Beckmann', 'GGX']
        parameter `distribution`


    Returns
    -------
    Shader
    """
    utils.check_enum_arg('Refraction BSDF', 'distribution', distribution, 'refraction_bsdf', ('BECKMANN', 'GGX'))
    node = Node('Refraction BSDF', {'Color': color, 'Roughness': roughness, 'IOR': ior, 'Normal': normal, 'Weight': weight}, distribution=distribution)
    return node._out

repeat_input(iterations=None) classmethod

Node Repeat Input

Parameters:

Name	Type	Description	Default
iterations	Integer	socket 'Iterations' (id: Iterations)	None

Returns:

Type	Description
Integer

Source code in core/generated/static_snd.py

@classmethod
def repeat_input(cls, iterations: Integer = None):
    """ > Node Repeat Input

    Parameters
    ----------
    iterations : Integer, optional
        socket 'Iterations' (id: Iterations)


    Returns
    -------
    Integer
    """
    node = Node('Repeat Input', {'Iterations': iterations})
    return node._out

repeat_output(inspection_index=0) classmethod

Node Repeat Output

Parameters:

Name	Type	Description	Default
inspection_index	int	parameter inspection_index	0

Returns:

Type	Description
None

Source code in core/generated/static_snd.py

@classmethod
def repeat_output(cls, inspection_index = 0):
    """ > Node Repeat Output

    Parameters
    ----------
    inspection_index : int
        parameter `inspection_index`


    Returns
    -------
    None
    """
    node = Node('Repeat Output', inspection_index=inspection_index)
    return node._out

reroute(input=None, socket_idname='NodeSocketColor') classmethod

Node Reroute

Parameters:

Name	Type	Description	Default
input	Color	socket 'Input' (id: Input)	None
socket_idname	str	parameter socket_idname	'NodeSocketColor'

Returns:

Type	Description
Color

Source code in core/generated/static_snd.py

@classmethod
def reroute(cls, input: Color = None, socket_idname = 'NodeSocketColor'):
    """ > Node Reroute

    Parameters
    ----------
    input : Color, optional
        socket 'Input' (id: Input)

    socket_idname : str
        parameter `socket_idname`


    Returns
    -------
    Color
    """
    node = Node('Reroute', {'Input': input}, socket_idname=socket_idname)
    return node._out

rgb_curves(color=None, factor=None) classmethod

Node RGB Curves

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
factor	Float	socket 'Factor' (id: Fac)	None

Returns:

Type	Description
Color

Source code in core/generated/static_snd.py

@classmethod
def rgb_curves(cls, color: Color = None, factor: Float = None):
    """ > Node RGB Curves

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    factor : Float, optional
        socket 'Factor' (id: Fac)


    Returns
    -------
    Color
    """
    node = NodeCurves('RGB Curves', {'Color': color, 'Fac': factor})
    return node._out

rgb_to_bw(color=None) classmethod

Node RGB to BW

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None

Returns:

Type	Description
Float

Source code in core/generated/static_snd.py

@classmethod
def rgb_to_bw(cls, color: Color = None):
    """ > Node RGB to BW

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)


    Returns
    -------
    Float
    """
    node = Node('RGB to BW', {'Color': color})
    return node._out

script(bytecode='', bytecode_hash='', filepath='', mode='INTERNAL', script=None, use_auto_update=False) classmethod

Node Script

Parameters:

Name	Type	Description	Default
bytecode	str	parameter bytecode	''
bytecode_hash	str	parameter bytecode_hash	''
filepath	str	parameter filepath	''
mode	Literal['Internal', 'External']	parameter mode	'INTERNAL'
script	NoneType	parameter script	None
use_auto_update	bool	parameter use_auto_update	False

Returns:

Type	Description
None

Source code in core/generated/static_snd.py

@classmethod
def script(cls,
                bytecode = '',
                bytecode_hash = '',
                filepath = '',
                mode: Literal['INTERNAL', 'EXTERNAL'] = 'INTERNAL',
                script = None,
                use_auto_update = False):
    """ > Node Script

    Parameters
    ----------
    bytecode : str
        parameter `bytecode`

    bytecode_hash : str
        parameter `bytecode_hash`

    filepath : str
        parameter `filepath`

    mode : Literal['Internal', 'External']
        parameter `mode`

    script : NoneType
        parameter `script`

    use_auto_update : bool
        parameter `use_auto_update`


    Returns
    -------
    None
    """
    utils.check_enum_arg('Script', 'mode', mode, 'script', ('INTERNAL', 'EXTERNAL'))
    node = Node('Script', bytecode=bytecode, bytecode_hash=bytecode_hash, filepath=filepath, mode=mode, script=script, use_auto_update=use_auto_update)
    return node._out

separate_bundle(named_sockets={}, bundle=None, define_signature=False, **sockets) classmethod

Node Separate Bundle

Parameters:

Name	Type	Description	Default
named_sockets	dict	Sockets created with string names	{}
bundle	Bundle	socket 'Bundle' (id: Bundle)	None
define_signature	bool	parameter define_signature	False
sockets	dict	Socket created with python name attributes	{}

Returns:

Type	Description
None

Source code in core/generated/static_snd.py

@classmethod
def separate_bundle(cls,
                named_sockets: dict = {},
                bundle: Bundle = None,
                define_signature = False,
                **sockets):
    """ > Node Separate Bundle

    Parameters
    ----------
    named_sockets : dict, default={}
        Sockets created with string names

    bundle : Bundle, optional
        socket 'Bundle' (id: Bundle)

    define_signature : bool
        parameter `define_signature`

    sockets : dict, default={}
        Socket created with python name attributes

    Returns
    -------
    None
    """
    node = Node('Separate Bundle', {'Bundle': bundle, **named_sockets}, define_signature=define_signature, **sockets)
    return node

separate_color(color=None, mode='RGB') classmethod

Node Separate Color

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
mode	Literal['RGB', 'HSV', 'HSL']	parameter mode	'RGB'

Returns:

Type	Description
Float	peer sockets: green_ (Float), blue_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def separate_color(cls, color: Color = None, mode: Literal['RGB', 'HSV', 'HSL'] = 'RGB'):
    """ > Node Separate Color

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    mode : Literal['RGB', 'HSV', 'HSL']
        parameter `mode`


    Returns
    -------
    Float
        peer sockets: green_ (Float), blue_ (Float)

    """
    utils.check_enum_arg('Separate Color', 'mode', mode, 'separate_color', ('RGB', 'HSV', 'HSL'))
    node = Node('Separate Color', {'Color': color}, mode=mode)
    return node

separate_xyz(vector=None) classmethod

Node Separate XYZ

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None

Returns:

Type	Description
Float	peer sockets: y_ (Float), z_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def separate_xyz(cls, vector: Vector = None):
    """ > Node Separate XYZ

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)


    Returns
    -------
    Float
        peer sockets: y_ (Float), z_ (Float)

    """
    node = Node('Separate XYZ', {'Vector': vector})
    return node

shader_to_rgb(shader=None) classmethod

Node Shader to RGB

Parameters:

Name	Type	Description	Default
shader	Shader	socket 'Shader' (id: Shader)	None

Returns:

Type	Description
Color	peer sockets: alpha_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def shader_to_rgb(cls, shader: Shader = None):
    """ > Node Shader to RGB

    Parameters
    ----------
    shader : Shader, optional
        socket 'Shader' (id: Shader)


    Returns
    -------
    Color
        peer sockets: alpha_ (Float)

    """
    node = Node('Shader to RGB', {'Shader': shader})
    return node._out

sheen_bsdf(color=None, roughness=None, normal=None, weight=None, distribution='MICROFIBER') classmethod

Node Sheen BSDF

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
normal	Vector	socket 'Normal' (id: Normal)	None
weight	Float	socket 'Weight' (id: Weight)	None
distribution	Literal['Ashikhmin', 'Microfiber']	parameter distribution	'MICROFIBER'

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def sheen_bsdf(cls,
                color: Color = None,
                roughness: Float = None,
                normal: Vector = None,
                weight: Float = None,
                distribution: Literal['ASHIKHMIN', 'MICROFIBER'] = 'MICROFIBER'):
    """ > Node Sheen BSDF

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    weight : Float, optional
        socket 'Weight' (id: Weight)

    distribution : Literal['Ashikhmin', 'Microfiber']
        parameter `distribution`


    Returns
    -------
    Shader
    """
    utils.check_enum_arg('Sheen BSDF', 'distribution', distribution, 'sheen_bsdf', ('ASHIKHMIN', 'MICROFIBER'))
    node = Node('Sheen BSDF', {'Color': color, 'Roughness': roughness, 'Normal': normal, 'Weight': weight}, distribution=distribution)
    return node._out

sky_texture(vector=None, aerosol_density=1.0, air_density=1.0, altitude=100.0, ground_albedo=0.30000001192092896, ozone_density=1.0, sky_type='MULTIPLE_SCATTERING', sun_disc=True, sun_elevation=0.2617993950843811, sun_intensity=1.0, sun_rotation=0.0, sun_size=0.009512044489383698, turbidity=2.200000047683716) classmethod

Node Sky Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
aerosol_density	float	parameter aerosol_density	1.0
air_density	float	parameter air_density	1.0
altitude	float	parameter altitude	100.0
ground_albedo	float	parameter ground_albedo	0.30000001192092896
ozone_density	float	parameter ozone_density	1.0
sky_type	Literal['Single Scattering', 'Multiple Scattering', 'Preetham', 'Hosek / Wilkie']	parameter sky_type	'MULTIPLE_SCATTERING'
sun_disc	bool	parameter sun_disc	True
sun_elevation	float	parameter sun_elevation	0.2617993950843811
sun_intensity	float	parameter sun_intensity	1.0
sun_rotation	float	parameter sun_rotation	0.0
sun_size	float	parameter sun_size	0.009512044489383698
turbidity	float	parameter turbidity	2.200000047683716

Returns:

Type	Description
Color

Source code in core/generated/static_snd.py

@classmethod
def sky_texture(cls,
                vector: Vector = None,
                aerosol_density = 1.0,
                air_density = 1.0,
                altitude = 100.0,
                ground_albedo = 0.30000001192092896,
                ozone_density = 1.0,
                sky_type: Literal['SINGLE_SCATTERING', 'MULTIPLE_SCATTERING', 'PREETHAM', 'HOSEK_WILKIE'] = 'MULTIPLE_SCATTERING',
                sun_disc = True,
                sun_elevation = 0.2617993950843811,
                sun_intensity = 1.0,
                sun_rotation = 0.0,
                sun_size = 0.009512044489383698,
                turbidity = 2.200000047683716):
    """ > Node Sky Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    aerosol_density : float
        parameter `aerosol_density`

    air_density : float
        parameter `air_density`

    altitude : float
        parameter `altitude`

    ground_albedo : float
        parameter `ground_albedo`

    ozone_density : float
        parameter `ozone_density`

    sky_type : Literal['Single Scattering', 'Multiple Scattering', 'Preetham', 'Hosek / Wilkie']
        parameter `sky_type`

    sun_disc : bool
        parameter `sun_disc`

    sun_elevation : float
        parameter `sun_elevation`

    sun_intensity : float
        parameter `sun_intensity`

    sun_rotation : float
        parameter `sun_rotation`

    sun_size : float
        parameter `sun_size`

    turbidity : float
        parameter `turbidity`


    Returns
    -------
    Color
    """
    utils.check_enum_arg('Sky Texture', 'sky_type', sky_type, 'sky_texture', ('SINGLE_SCATTERING', 'MULTIPLE_SCATTERING', 'PREETHAM', 'HOSEK_WILKIE'))
    node = Node('Sky Texture', {'Vector': vector}, aerosol_density=aerosol_density, air_density=air_density, altitude=altitude, ground_albedo=ground_albedo, ozone_density=ozone_density, sky_type=sky_type, sun_disc=sun_disc, sun_elevation=sun_elevation, sun_intensity=sun_intensity, sun_rotation=sun_rotation, sun_size=sun_size, turbidity=turbidity)
    return node._out

specular_bsdf(base_color=None, specular=None, roughness=None, emissive_color=None, transparency=None, normal=None, clear_coat=None, clear_coat_roughness=None, clear_coat_normal=None, weight=None) classmethod

Node Specular BSDF

Parameters:

Name	Type	Description	Default
base_color	Color	socket 'Base Color' (id: Base Color)	None
specular	Color	socket 'Specular' (id: Specular)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
emissive_color	Color	socket 'Emissive Color' (id: Emissive Color)	None
transparency	Float	socket 'Transparency' (id: Transparency)	None
normal	Vector	socket 'Normal' (id: Normal)	None
clear_coat	Float	socket 'Clear Coat' (id: Clear Coat)	None
clear_coat_roughness	Float	socket 'Clear Coat Roughness' (id: Clear Coat Roughness)	None
clear_coat_normal	Vector	socket 'Clear Coat Normal' (id: Clear Coat Normal)	None
weight	Float	socket 'Weight' (id: Weight)	None

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def specular_bsdf(cls,
                base_color: Color = None,
                specular: Color = None,
                roughness: Float = None,
                emissive_color: Color = None,
                transparency: Float = None,
                normal: Vector = None,
                clear_coat: Float = None,
                clear_coat_roughness: Float = None,
                clear_coat_normal: Vector = None,
                weight: Float = None):
    """ > Node Specular BSDF

    Parameters
    ----------
    base_color : Color, optional
        socket 'Base Color' (id: Base Color)

    specular : Color, optional
        socket 'Specular' (id: Specular)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    emissive_color : Color, optional
        socket 'Emissive Color' (id: Emissive Color)

    transparency : Float, optional
        socket 'Transparency' (id: Transparency)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    clear_coat : Float, optional
        socket 'Clear Coat' (id: Clear Coat)

    clear_coat_roughness : Float, optional
        socket 'Clear Coat Roughness' (id: Clear Coat Roughness)

    clear_coat_normal : Vector, optional
        socket 'Clear Coat Normal' (id: Clear Coat Normal)

    weight : Float, optional
        socket 'Weight' (id: Weight)


    Returns
    -------
    Shader
    """
    node = Node('Specular BSDF', {'Base Color': base_color, 'Specular': specular, 'Roughness': roughness, 'Emissive Color': emissive_color, 'Transparency': transparency, 'Normal': normal, 'Clear Coat': clear_coat, 'Clear Coat Roughness': clear_coat_roughness, 'Clear Coat Normal': clear_coat_normal, 'Weight': weight})
    return node._out

subsurface_scattering(color=None, scale=None, radius=None, ior=None, roughness=None, anisotropy=None, normal=None, weight=None, falloff='RANDOM_WALK') classmethod

Node Subsurface Scattering

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
scale	Float	socket 'Scale' (id: Scale)	None
radius	Vector	socket 'Radius' (id: Radius)	None
ior	Float	socket 'IOR' (id: IOR)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
anisotropy	Float	socket 'Anisotropy' (id: Anisotropy)	None
normal	Vector	socket 'Normal' (id: Normal)	None
weight	Float	socket 'Weight' (id: Weight)	None
falloff	Literal['Christensen-Burley', 'Random Walk', 'Random Walk (Skin)']	parameter falloff	'RANDOM_WALK'

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def subsurface_scattering(cls,
                color: Color = None,
                scale: Float = None,
                radius: Vector = None,
                ior: Float = None,
                roughness: Float = None,
                anisotropy: Float = None,
                normal: Vector = None,
                weight: Float = None,
                falloff: Literal['BURLEY', 'RANDOM_WALK', 'RANDOM_WALK_SKIN'] = 'RANDOM_WALK'):
    """ > Node Subsurface Scattering

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    radius : Vector, optional
        socket 'Radius' (id: Radius)

    ior : Float, optional
        socket 'IOR' (id: IOR)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    anisotropy : Float, optional
        socket 'Anisotropy' (id: Anisotropy)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    weight : Float, optional
        socket 'Weight' (id: Weight)

    falloff : Literal['Christensen-Burley', 'Random Walk', 'Random Walk (Skin)']
        parameter `falloff`


    Returns
    -------
    Shader
    """
    utils.check_enum_arg('Subsurface Scattering', 'falloff', falloff, 'subsurface_scattering', ('BURLEY', 'RANDOM_WALK', 'RANDOM_WALK_SKIN'))
    node = Node('Subsurface Scattering', {'Color': color, 'Scale': scale, 'Radius': radius, 'IOR': ior, 'Roughness': roughness, 'Anisotropy': anisotropy, 'Normal': normal, 'Weight': weight}, falloff=falloff)
    return node._out

tangent(axis='Z', direction_type='RADIAL', uv_map='') classmethod

Node Tangent

Parameters:

Name	Type	Description	Default
axis	Literal['X', 'Y', 'Z']	parameter axis	'Z'
direction_type	Literal['Radial', 'UV Map']	parameter direction_type	'RADIAL'
uv_map	str	parameter uv_map	''

Returns:

Type	Description
Vector

Source code in core/generated/static_snd.py

@classmethod
def tangent(cls,
                axis: Literal['X', 'Y', 'Z'] = 'Z',
                direction_type: Literal['RADIAL', 'UV_MAP'] = 'RADIAL',
                uv_map = ''):
    """ > Node Tangent

    Parameters
    ----------
    axis : Literal['X', 'Y', 'Z']
        parameter `axis`

    direction_type : Literal['Radial', 'UV Map']
        parameter `direction_type`

    uv_map : str
        parameter `uv_map`


    Returns
    -------
    Vector
    """
    utils.check_enum_arg('Tangent', 'axis', axis, 'tangent', ('X', 'Y', 'Z'))
    utils.check_enum_arg('Tangent', 'direction_type', direction_type, 'tangent', ('RADIAL', 'UV_MAP'))
    node = Node('Tangent', axis=axis, direction_type=direction_type, uv_map=uv_map)
    return node._out

texture_coordinate(from_instancer=False, object=None) classmethod

Node Texture Coordinate

Parameters:

Name	Type	Description	Default
from_instancer	bool	parameter from_instancer	False
object	NoneType	parameter object	None

Returns:

Type	Description
Vector	peer sockets: normal_ (Vector), uv_ (Vector), object_ (Vector), camera_ (Vector), window_ (Vector), reflection_ (Vector)

Source code in core/generated/static_snd.py

@classmethod
def texture_coordinate(cls, from_instancer = False, object = None):
    """ > Node Texture Coordinate

    Parameters
    ----------
    from_instancer : bool
        parameter `from_instancer`

    object : NoneType
        parameter `object`


    Returns
    -------
    Vector
        peer sockets: normal_ (Vector), uv_ (Vector), object_ (Vector), camera_ (Vector), window_ (Vector), reflection_ (Vector)

    """
    node = Node('Texture Coordinate', from_instancer=from_instancer, object=object)
    return node

toon_bsdf(color=None, size=None, smooth=None, normal=None, weight=None, component='DIFFUSE') classmethod

Node Toon BSDF

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
size	Float	socket 'Size' (id: Size)	None
smooth	Float	socket 'Smooth' (id: Smooth)	None
normal	Vector	socket 'Normal' (id: Normal)	None
weight	Float	socket 'Weight' (id: Weight)	None
component	Literal['Diffuse', 'Glossy']	parameter component	'DIFFUSE'

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def toon_bsdf(cls,
                color: Color = None,
                size: Float = None,
                smooth: Float = None,
                normal: Vector = None,
                weight: Float = None,
                component: Literal['DIFFUSE', 'GLOSSY'] = 'DIFFUSE'):
    """ > Node Toon BSDF

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    size : Float, optional
        socket 'Size' (id: Size)

    smooth : Float, optional
        socket 'Smooth' (id: Smooth)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    weight : Float, optional
        socket 'Weight' (id: Weight)

    component : Literal['Diffuse', 'Glossy']
        parameter `component`


    Returns
    -------
    Shader
    """
    utils.check_enum_arg('Toon BSDF', 'component', component, 'toon_bsdf', ('DIFFUSE', 'GLOSSY'))
    node = Node('Toon BSDF', {'Color': color, 'Size': size, 'Smooth': smooth, 'Normal': normal, 'Weight': weight}, component=component)
    return node._out

translucent_bsdf(color=None, normal=None, weight=None) classmethod

Node Translucent BSDF

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
normal	Vector	socket 'Normal' (id: Normal)	None
weight	Float	socket 'Weight' (id: Weight)	None

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def translucent_bsdf(cls, color: Color = None, normal: Vector = None, weight: Float = None):
    """ > Node Translucent BSDF

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    normal : Vector, optional
        socket 'Normal' (id: Normal)

    weight : Float, optional
        socket 'Weight' (id: Weight)


    Returns
    -------
    Shader
    """
    node = Node('Translucent BSDF', {'Color': color, 'Normal': normal, 'Weight': weight})
    return node._out

transparent_bsdf(color=None, weight=None) classmethod

Node Transparent BSDF

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
weight	Float	socket 'Weight' (id: Weight)	None

Returns:

Type	Description
Shader

Source code in core/generated/static_snd.py

@classmethod
def transparent_bsdf(cls, color: Color = None, weight: Float = None):
    """ > Node Transparent BSDF

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    weight : Float, optional
        socket 'Weight' (id: Weight)


    Returns
    -------
    Shader
    """
    node = Node('Transparent BSDF', {'Color': color, 'Weight': weight})
    return node._out

uv_along_stroke(use_tips=False) classmethod

Node UV Along Stroke

Parameters:

Name	Type	Description	Default
use_tips	bool	parameter use_tips	False

Returns:

Type	Description
Vector

Source code in core/generated/static_snd.py

@classmethod
def uv_along_stroke(cls, use_tips = False):
    """ > Node UV Along Stroke

    Parameters
    ----------
    use_tips : bool
        parameter `use_tips`


    Returns
    -------
    Vector
    """
    node = Node('UV Along Stroke', use_tips=use_tips)
    return node._out

uv_map(from_instancer=False, uv_map='') classmethod

Node UV Map

Parameters:

Name	Type	Description	Default
from_instancer	bool	parameter from_instancer	False
uv_map	str	parameter uv_map	''

Returns:

Type	Description
Vector

Source code in core/generated/static_snd.py

@classmethod
def uv_map(cls, from_instancer = False, uv_map = ''):
    """ > Node UV Map

    Parameters
    ----------
    from_instancer : bool
        parameter `from_instancer`

    uv_map : str
        parameter `uv_map`


    Returns
    -------
    Vector
    """
    node = Node('UV Map', from_instancer=from_instancer, uv_map=uv_map)
    return node._out

value()

Node Value

Returns:

Type	Description
Float

Source code in core/generated/static_snd.py

@utils.classproperty
def value(self):
    """ > Node Value

    Returns
    -------
    Float
    """
    node = Node('Value', )
    return node._out

vector_curves(vector=None, factor=None) classmethod

Node Vector Curves

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
factor	Float	socket 'Factor' (id: Fac)	None

Returns:

Type	Description
Vector

Source code in core/generated/static_snd.py

@classmethod
def vector_curves(cls, vector: Vector = None, factor: Float = None):
    """ > Node Vector Curves

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    factor : Float, optional
        socket 'Factor' (id: Fac)


    Returns
    -------
    Vector
    """
    node = NodeCurves('Vector Curves', {'Vector': vector, 'Fac': factor})
    return node._out

vector_displacement(vector=None, midlevel=None, scale=None, space='TANGENT') classmethod

Node Vector Displacement

Parameters:

Name	Type	Description	Default
vector	Color	socket 'Vector' (id: Vector)	None
midlevel	Float	socket 'Midlevel' (id: Midlevel)	None
scale	Float	socket 'Scale' (id: Scale)	None
space	Literal['Tangent Space', 'Object Space', 'World Space']	parameter space	'TANGENT'

Returns:

Type	Description
Vector

Source code in core/generated/static_snd.py

@classmethod
def vector_displacement(cls,
                vector: Color = None,
                midlevel: Float = None,
                scale: Float = None,
                space: Literal['TANGENT', 'OBJECT', 'WORLD'] = 'TANGENT'):
    """ > Node Vector Displacement

    Parameters
    ----------
    vector : Color, optional
        socket 'Vector' (id: Vector)

    midlevel : Float, optional
        socket 'Midlevel' (id: Midlevel)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    space : Literal['Tangent Space', 'Object Space', 'World Space']
        parameter `space`


    Returns
    -------
    Vector
    """
    utils.check_enum_arg('Vector Displacement', 'space', space, 'vector_displacement', ('TANGENT', 'OBJECT', 'WORLD'))
    node = Node('Vector Displacement', {'Vector': vector, 'Midlevel': midlevel, 'Scale': scale}, space=space)
    return node._out

vector_math(vector=None, vector_1=None, vector_2=None, scale=None, operation='ADD') classmethod

Node Vector Math

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
vector_1	Vector	socket 'Vector' (id: Vector_001)	None
vector_2	Vector	socket 'Vector' (id: Vector_002)	None
scale	Float	socket 'Scale' (id: Scale)	None
operation	Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Cross Product', 'Project', 'Reflect', 'Refract', 'Faceforward', 'Dot Product', 'Distance', 'Length', 'Scale', 'Normalize', 'Absolute', 'Power', 'Sign', 'Minimum', 'Maximum', 'Round', 'Floor', 'Ceil', 'Fraction', 'Modulo', 'Wrap', 'Snap', 'Sine', 'Cosine', 'Tangent']	parameter operation	'ADD'

Returns:

Type	Description
Vector

Source code in core/generated/static_snd.py

@classmethod
def vector_math(cls,
                vector: Vector = None,
                vector_1: Vector = None,
                vector_2: Vector = None,
                scale: Float = None,
                operation: Literal['ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'CROSS_PRODUCT', 'PROJECT', 'REFLECT', 'REFRACT', 'FACEFORWARD', 'DOT_PRODUCT', 'DISTANCE', 'LENGTH', 'SCALE', 'NORMALIZE', 'ABSOLUTE', 'POWER', 'SIGN', 'MINIMUM', 'MAXIMUM', 'ROUND', 'FLOOR', 'CEIL', 'FRACTION', 'MODULO', 'WRAP', 'SNAP', 'SINE', 'COSINE', 'TANGENT'] = 'ADD'):
    """ > Node Vector Math

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    vector_1 : Vector, optional
        socket 'Vector' (id: Vector_001)

    vector_2 : Vector, optional
        socket 'Vector' (id: Vector_002)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    operation : Literal['Add', 'Subtract', 'Multiply', 'Divide', 'Multiply Add', 'Cross Product', 'Project', 'Reflect', 'Refract', 'Faceforward', 'Dot Product', 'Distance', 'Length', 'Scale', 'Normalize', 'Absolute', 'Power', 'Sign', 'Minimum', 'Maximum', 'Round', 'Floor', 'Ceil', 'Fraction', 'Modulo', 'Wrap', 'Snap', 'Sine', 'Cosine', 'Tangent']
        parameter `operation`


    Returns
    -------
    Vector
    """
    utils.check_enum_arg('Vector Math', 'operation', operation, 'vector_math', ('ADD', 'SUBTRACT', 'MULTIPLY', 'DIVIDE', 'MULTIPLY_ADD', 'CROSS_PRODUCT', 'PROJECT', 'REFLECT', 'REFRACT', 'FACEFORWARD', 'DOT_PRODUCT', 'DISTANCE', 'LENGTH', 'SCALE', 'NORMALIZE', 'ABSOLUTE', 'POWER', 'SIGN', 'MINIMUM', 'MAXIMUM', 'ROUND', 'FLOOR', 'CEIL', 'FRACTION', 'MODULO', 'WRAP', 'SNAP', 'SINE', 'COSINE', 'TANGENT'))
    node = Node('Vector Math', {'Vector': vector, 'Vector_001': vector_1, 'Vector_002': vector_2, 'Scale': scale}, operation=operation)
    return node._out

vector_rotate(vector=None, center=None, axis=None, angle=None, rotation=None, invert=False, rotation_type='AXIS_ANGLE') classmethod

Node Vector Rotate

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
center	Vector	socket 'Center' (id: Center)	None
axis	Vector	socket 'Axis' (id: Axis)	None
angle	Float	socket 'Angle' (id: Angle)	None
rotation	Vector	socket 'Rotation' (id: Rotation)	None
invert	bool	parameter invert	False
rotation_type	Literal['Axis Angle', 'X Axis', 'Y Axis', 'Z Axis', 'Euler']	parameter rotation_type	'AXIS_ANGLE'

Returns:

Type	Description
Vector

Source code in core/generated/static_snd.py

@classmethod
def vector_rotate(cls,
                vector: Vector = None,
                center: Vector = None,
                axis: Vector = None,
                angle: Float = None,
                rotation: Vector = None,
                invert = False,
                rotation_type: Literal['AXIS_ANGLE', 'X_AXIS', 'Y_AXIS', 'Z_AXIS', 'EULER_XYZ'] = 'AXIS_ANGLE'):
    """ > Node Vector Rotate

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    center : Vector, optional
        socket 'Center' (id: Center)

    axis : Vector, optional
        socket 'Axis' (id: Axis)

    angle : Float, optional
        socket 'Angle' (id: Angle)

    rotation : Vector, optional
        socket 'Rotation' (id: Rotation)

    invert : bool
        parameter `invert`

    rotation_type : Literal['Axis Angle', 'X Axis', 'Y Axis', 'Z Axis', 'Euler']
        parameter `rotation_type`


    Returns
    -------
    Vector
    """
    utils.check_enum_arg('Vector Rotate', 'rotation_type', rotation_type, 'vector_rotate', ('AXIS_ANGLE', 'X_AXIS', 'Y_AXIS', 'Z_AXIS', 'EULER_XYZ'))
    node = Node('Vector Rotate', {'Vector': vector, 'Center': center, 'Axis': axis, 'Angle': angle, 'Rotation': rotation}, invert=invert, rotation_type=rotation_type)
    return node._out

vector_transform(vector=None, convert_from='WORLD', convert_to='OBJECT', vector_type='VECTOR') classmethod

Node Vector Transform

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
convert_from	Literal['World', 'Object', 'Camera']	parameter convert_from	'WORLD'
convert_to	Literal['World', 'Object', 'Camera']	parameter convert_to	'OBJECT'
vector_type	Literal['Point', 'Vector', 'Normal']	parameter vector_type	'VECTOR'

Returns:

Type	Description
Vector

Source code in core/generated/static_snd.py

@classmethod
def vector_transform(cls,
                vector: Vector = None,
                convert_from: Literal['WORLD', 'OBJECT', 'CAMERA'] = 'WORLD',
                convert_to: Literal['WORLD', 'OBJECT', 'CAMERA'] = 'OBJECT',
                vector_type: Literal['POINT', 'VECTOR', 'NORMAL'] = 'VECTOR'):
    """ > Node Vector Transform

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    convert_from : Literal['World', 'Object', 'Camera']
        parameter `convert_from`

    convert_to : Literal['World', 'Object', 'Camera']
        parameter `convert_to`

    vector_type : Literal['Point', 'Vector', 'Normal']
        parameter `vector_type`


    Returns
    -------
    Vector
    """
    utils.check_enum_arg('Vector Transform', 'convert_from', convert_from, 'vector_transform', ('WORLD', 'OBJECT', 'CAMERA'))
    utils.check_enum_arg('Vector Transform', 'convert_to', convert_to, 'vector_transform', ('WORLD', 'OBJECT', 'CAMERA'))
    utils.check_enum_arg('Vector Transform', 'vector_type', vector_type, 'vector_transform', ('POINT', 'VECTOR', 'NORMAL'))
    node = Node('Vector Transform', {'Vector': vector}, convert_from=convert_from, convert_to=convert_to, vector_type=vector_type)
    return node._out

volume_absorption(color=None, density=None, weight=None) classmethod

Node Volume Absorption

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
density	Float	socket 'Density' (id: Density)	None
weight	Float	socket 'Weight' (id: Weight)	None

Returns:

Type	Description
VolumeShader

Source code in core/generated/static_snd.py

@classmethod
def volume_absorption(cls, color: Color = None, density: Float = None, weight: Float = None):
    """ > Node Volume Absorption

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    density : Float, optional
        socket 'Density' (id: Density)

    weight : Float, optional
        socket 'Weight' (id: Weight)


    Returns
    -------
    VolumeShader
    """
    node = Node('Volume Absorption', {'Color': color, 'Density': density, 'Weight': weight})
    return node._out

volume_coefficients(weight=None, absorption_coefficients=None, scatter_coefficients=None, anisotropy=None, ior=None, backscatter=None, alpha=None, diameter=None, emission_coefficients=None, phase='HENYEY_GREENSTEIN') classmethod

Node Volume Coefficients

Parameters:

Name	Type	Description	Default
weight	Float	socket 'Weight' (id: Weight)	None
absorption_coefficients	Vector	socket 'Absorption Coefficients' (id: Absorption Coefficients)	None
scatter_coefficients	Vector	socket 'Scatter Coefficients' (id: Scatter Coefficients)	None
anisotropy	Float	socket 'Anisotropy' (id: Anisotropy)	None
ior	Float	socket 'IOR' (id: IOR)	None
backscatter	Float	socket 'Backscatter' (id: Backscatter)	None
alpha	Float	socket 'Alpha' (id: Alpha)	None
diameter	Float	socket 'Diameter' (id: Diameter)	None
emission_coefficients	Vector	socket 'Emission Coefficients' (id: Emission Coefficients)	None
phase	Literal['Henyey-Greenstein', 'Fournier-Forand', 'Draine', 'Rayleigh', 'Mie']	parameter phase	'HENYEY_GREENSTEIN'

Returns:

Type	Description
VolumeShader

Source code in core/generated/static_snd.py

@classmethod
def volume_coefficients(cls,
                weight: Float = None,
                absorption_coefficients: Vector = None,
                scatter_coefficients: Vector = None,
                anisotropy: Float = None,
                ior: Float = None,
                backscatter: Float = None,
                alpha: Float = None,
                diameter: Float = None,
                emission_coefficients: Vector = None,
                phase: Literal['HENYEY_GREENSTEIN', 'FOURNIER_FORAND', 'DRAINE', 'RAYLEIGH', 'MIE'] = 'HENYEY_GREENSTEIN'):
    """ > Node Volume Coefficients

    Parameters
    ----------
    weight : Float, optional
        socket 'Weight' (id: Weight)

    absorption_coefficients : Vector, optional
        socket 'Absorption Coefficients' (id: Absorption Coefficients)

    scatter_coefficients : Vector, optional
        socket 'Scatter Coefficients' (id: Scatter Coefficients)

    anisotropy : Float, optional
        socket 'Anisotropy' (id: Anisotropy)

    ior : Float, optional
        socket 'IOR' (id: IOR)

    backscatter : Float, optional
        socket 'Backscatter' (id: Backscatter)

    alpha : Float, optional
        socket 'Alpha' (id: Alpha)

    diameter : Float, optional
        socket 'Diameter' (id: Diameter)

    emission_coefficients : Vector, optional
        socket 'Emission Coefficients' (id: Emission Coefficients)

    phase : Literal['Henyey-Greenstein', 'Fournier-Forand', 'Draine', 'Rayleigh', 'Mie']
        parameter `phase`


    Returns
    -------
    VolumeShader
    """
    utils.check_enum_arg('Volume Coefficients', 'phase', phase, 'volume_coefficients', ('HENYEY_GREENSTEIN', 'FOURNIER_FORAND', 'DRAINE', 'RAYLEIGH', 'MIE'))
    node = Node('Volume Coefficients', {'Weight': weight, 'Absorption Coefficients': absorption_coefficients, 'Scatter Coefficients': scatter_coefficients, 'Anisotropy': anisotropy, 'IOR': ior, 'Backscatter': backscatter, 'Alpha': alpha, 'Diameter': diameter, 'Emission Coefficients': emission_coefficients}, phase=phase)
    return node._out

volume_info() classmethod

Node Volume Info

Returns:

Type	Description
Color	peer sockets: density_ (Float), flame_ (Float), temperature_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def volume_info(cls):
    """ > Node Volume Info

    Returns
    -------
    Color
        peer sockets: density_ (Float), flame_ (Float), temperature_ (Float)

    """
    node = Node('Volume Info', )
    return node

volume_scatter(color=None, density=None, anisotropy=None, ior=None, backscatter=None, alpha=None, diameter=None, weight=None, phase='HENYEY_GREENSTEIN') classmethod

Node Volume Scatter

Parameters:

Name	Type	Description	Default
color	Color	socket 'Color' (id: Color)	None
density	Float	socket 'Density' (id: Density)	None
anisotropy	Float	socket 'Anisotropy' (id: Anisotropy)	None
ior	Float	socket 'IOR' (id: IOR)	None
backscatter	Float	socket 'Backscatter' (id: Backscatter)	None
alpha	Float	socket 'Alpha' (id: Alpha)	None
diameter	Float	socket 'Diameter' (id: Diameter)	None
weight	Float	socket 'Weight' (id: Weight)	None
phase	Literal['Henyey-Greenstein', 'Fournier-Forand', 'Draine', 'Rayleigh', 'Mie']	parameter phase	'HENYEY_GREENSTEIN'

Returns:

Type	Description
VolumeShader

Source code in core/generated/static_snd.py

@classmethod
def volume_scatter(cls,
                color: Color = None,
                density: Float = None,
                anisotropy: Float = None,
                ior: Float = None,
                backscatter: Float = None,
                alpha: Float = None,
                diameter: Float = None,
                weight: Float = None,
                phase: Literal['HENYEY_GREENSTEIN', 'FOURNIER_FORAND', 'DRAINE', 'RAYLEIGH', 'MIE'] = 'HENYEY_GREENSTEIN'):
    """ > Node Volume Scatter

    Parameters
    ----------
    color : Color, optional
        socket 'Color' (id: Color)

    density : Float, optional
        socket 'Density' (id: Density)

    anisotropy : Float, optional
        socket 'Anisotropy' (id: Anisotropy)

    ior : Float, optional
        socket 'IOR' (id: IOR)

    backscatter : Float, optional
        socket 'Backscatter' (id: Backscatter)

    alpha : Float, optional
        socket 'Alpha' (id: Alpha)

    diameter : Float, optional
        socket 'Diameter' (id: Diameter)

    weight : Float, optional
        socket 'Weight' (id: Weight)

    phase : Literal['Henyey-Greenstein', 'Fournier-Forand', 'Draine', 'Rayleigh', 'Mie']
        parameter `phase`


    Returns
    -------
    VolumeShader
    """
    utils.check_enum_arg('Volume Scatter', 'phase', phase, 'volume_scatter', ('HENYEY_GREENSTEIN', 'FOURNIER_FORAND', 'DRAINE', 'RAYLEIGH', 'MIE'))
    node = Node('Volume Scatter', {'Color': color, 'Density': density, 'Anisotropy': anisotropy, 'IOR': ior, 'Backscatter': backscatter, 'Alpha': alpha, 'Diameter': diameter, 'Weight': weight}, phase=phase)
    return node._out

voronoi_texture(vector=None, w=None, scale=None, detail=None, roughness=None, lacunarity=None, smoothness=None, exponent=None, randomness=None, distance='EUCLIDEAN', feature='F1', normalize=False, voronoi_dimensions='3D') classmethod

Node Voronoi Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
w	Float	socket 'W' (id: W)	None
scale	Float	socket 'Scale' (id: Scale)	None
detail	Float	socket 'Detail' (id: Detail)	None
roughness	Float	socket 'Roughness' (id: Roughness)	None
lacunarity	Float	socket 'Lacunarity' (id: Lacunarity)	None
smoothness	Float	socket 'Smoothness' (id: Smoothness)	None
exponent	Float	socket 'Exponent' (id: Exponent)	None
randomness	Float	socket 'Randomness' (id: Randomness)	None
distance	Literal['Euclidean', 'Manhattan', 'Chebychev', 'Minkowski']	parameter distance	'EUCLIDEAN'
feature	Literal['F1', 'F2', 'Smooth F1', 'Distance to Edge', 'N-Sphere Radius']	parameter feature	'F1'
normalize	bool	parameter normalize	False
voronoi_dimensions	Literal['1D', '2D', '3D', '4D']	parameter voronoi_dimensions	'3D'

Returns:

Type	Description
Float	peer sockets: color_ (Color), position_ (Vector)

Source code in core/generated/static_snd.py

@classmethod
def voronoi_texture(cls,
                vector: Vector = None,
                w: Float = None,
                scale: Float = None,
                detail: Float = None,
                roughness: Float = None,
                lacunarity: Float = None,
                smoothness: Float = None,
                exponent: Float = None,
                randomness: Float = None,
                distance: Literal['EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'] = 'EUCLIDEAN',
                feature: Literal['F1', 'F2', 'SMOOTH_F1', 'DISTANCE_TO_EDGE', 'N_SPHERE_RADIUS'] = 'F1',
                normalize = False,
                voronoi_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D'):
    """ > Node Voronoi Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    w : Float, optional
        socket 'W' (id: W)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    detail : Float, optional
        socket 'Detail' (id: Detail)

    roughness : Float, optional
        socket 'Roughness' (id: Roughness)

    lacunarity : Float, optional
        socket 'Lacunarity' (id: Lacunarity)

    smoothness : Float, optional
        socket 'Smoothness' (id: Smoothness)

    exponent : Float, optional
        socket 'Exponent' (id: Exponent)

    randomness : Float, optional
        socket 'Randomness' (id: Randomness)

    distance : Literal['Euclidean', 'Manhattan', 'Chebychev', 'Minkowski']
        parameter `distance`

    feature : Literal['F1', 'F2', 'Smooth F1', 'Distance to Edge', 'N-Sphere Radius']
        parameter `feature`

    normalize : bool
        parameter `normalize`

    voronoi_dimensions : Literal['1D', '2D', '3D', '4D']
        parameter `voronoi_dimensions`


    Returns
    -------
    Float
        peer sockets: color_ (Color), position_ (Vector)

    """
    utils.check_enum_arg('Voronoi Texture', 'distance', distance, 'voronoi_texture', ('EUCLIDEAN', 'MANHATTAN', 'CHEBYCHEV', 'MINKOWSKI'))
    utils.check_enum_arg('Voronoi Texture', 'feature', feature, 'voronoi_texture', ('F1', 'F2', 'SMOOTH_F1', 'DISTANCE_TO_EDGE', 'N_SPHERE_RADIUS'))
    utils.check_enum_arg('Voronoi Texture', 'voronoi_dimensions', voronoi_dimensions, 'voronoi_texture', ('1D', '2D', '3D', '4D'))
    node = Node('Voronoi Texture', {'Vector': vector, 'W': w, 'Scale': scale, 'Detail': detail, 'Roughness': roughness, 'Lacunarity': lacunarity, 'Smoothness': smoothness, 'Exponent': exponent, 'Randomness': randomness}, distance=distance, feature=feature, normalize=normalize, voronoi_dimensions=voronoi_dimensions)
    return node._out

wave_texture(vector=None, scale=None, distortion=None, detail=None, detail_scale=None, detail_roughness=None, phase_offset=None, bands_direction='X', rings_direction='X', wave_profile='SIN', wave_type='BANDS') classmethod

Node Wave Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
scale	Float	socket 'Scale' (id: Scale)	None
distortion	Float	socket 'Distortion' (id: Distortion)	None
detail	Float	socket 'Detail' (id: Detail)	None
detail_scale	Float	socket 'Detail Scale' (id: Detail Scale)	None
detail_roughness	Float	socket 'Detail Roughness' (id: Detail Roughness)	None
phase_offset	Float	socket 'Phase Offset' (id: Phase Offset)	None
bands_direction	Literal['X', 'Y', 'Z', 'Diagonal']	parameter bands_direction	'X'
rings_direction	Literal['X', 'Y', 'Z', 'Spherical']	parameter rings_direction	'X'
wave_profile	Literal['Sine', 'Saw', 'Triangle']	parameter wave_profile	'SIN'
wave_type	Literal['Bands', 'Rings']	parameter wave_type	'BANDS'

Returns:

Type	Description
Color	peer sockets: factor_ (Float)

Source code in core/generated/static_snd.py

@classmethod
def wave_texture(cls,
                vector: Vector = None,
                scale: Float = None,
                distortion: Float = None,
                detail: Float = None,
                detail_scale: Float = None,
                detail_roughness: Float = None,
                phase_offset: Float = None,
                bands_direction: Literal['X', 'Y', 'Z', 'DIAGONAL'] = 'X',
                rings_direction: Literal['X', 'Y', 'Z', 'SPHERICAL'] = 'X',
                wave_profile: Literal['SIN', 'SAW', 'TRI'] = 'SIN',
                wave_type: Literal['BANDS', 'RINGS'] = 'BANDS'):
    """ > Node Wave Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    scale : Float, optional
        socket 'Scale' (id: Scale)

    distortion : Float, optional
        socket 'Distortion' (id: Distortion)

    detail : Float, optional
        socket 'Detail' (id: Detail)

    detail_scale : Float, optional
        socket 'Detail Scale' (id: Detail Scale)

    detail_roughness : Float, optional
        socket 'Detail Roughness' (id: Detail Roughness)

    phase_offset : Float, optional
        socket 'Phase Offset' (id: Phase Offset)

    bands_direction : Literal['X', 'Y', 'Z', 'Diagonal']
        parameter `bands_direction`

    rings_direction : Literal['X', 'Y', 'Z', 'Spherical']
        parameter `rings_direction`

    wave_profile : Literal['Sine', 'Saw', 'Triangle']
        parameter `wave_profile`

    wave_type : Literal['Bands', 'Rings']
        parameter `wave_type`


    Returns
    -------
    Color
        peer sockets: factor_ (Float)

    """
    utils.check_enum_arg('Wave Texture', 'bands_direction', bands_direction, 'wave_texture', ('X', 'Y', 'Z', 'DIAGONAL'))
    utils.check_enum_arg('Wave Texture', 'rings_direction', rings_direction, 'wave_texture', ('X', 'Y', 'Z', 'SPHERICAL'))
    utils.check_enum_arg('Wave Texture', 'wave_profile', wave_profile, 'wave_texture', ('SIN', 'SAW', 'TRI'))
    utils.check_enum_arg('Wave Texture', 'wave_type', wave_type, 'wave_texture', ('BANDS', 'RINGS'))
    node = Node('Wave Texture', {'Vector': vector, 'Scale': scale, 'Distortion': distortion, 'Detail': detail, 'Detail Scale': detail_scale, 'Detail Roughness': detail_roughness, 'Phase Offset': phase_offset}, bands_direction=bands_direction, rings_direction=rings_direction, wave_profile=wave_profile, wave_type=wave_type)
    return node._out

wavelength(wavelength=None) classmethod

Node Wavelength

Parameters:

Name	Type	Description	Default
wavelength	Float	socket 'Wavelength' (id: Wavelength)	None

Returns:

Type	Description
Color

Source code in core/generated/static_snd.py

@classmethod
def wavelength(cls, wavelength: Float = None):
    """ > Node Wavelength

    Parameters
    ----------
    wavelength : Float, optional
        socket 'Wavelength' (id: Wavelength)


    Returns
    -------
    Color
    """
    node = Node('Wavelength', {'Wavelength': wavelength})
    return node._out

white_noise_texture(vector=None, w=None, noise_dimensions='3D') classmethod

Node White Noise Texture

Parameters:

Name	Type	Description	Default
vector	Vector	socket 'Vector' (id: Vector)	None
w	Float	socket 'W' (id: W)	None
noise_dimensions	Literal['1D', '2D', '3D', '4D']	parameter noise_dimensions	'3D'

Returns:

Type	Description
Float	peer sockets: color_ (Color)

Source code in core/generated/static_snd.py

@classmethod
def white_noise_texture(cls,
                vector: Vector = None,
                w: Float = None,
                noise_dimensions: Literal['1D', '2D', '3D', '4D'] = '3D'):
    """ > Node White Noise Texture

    Parameters
    ----------
    vector : Vector, optional
        socket 'Vector' (id: Vector)

    w : Float, optional
        socket 'W' (id: W)

    noise_dimensions : Literal['1D', '2D', '3D', '4D']
        parameter `noise_dimensions`


    Returns
    -------
    Float
        peer sockets: color_ (Color)

    """
    utils.check_enum_arg('White Noise Texture', 'noise_dimensions', noise_dimensions, 'white_noise_texture', ('1D', '2D', '3D', '4D'))
    node = Node('White Noise Texture', {'Vector': vector, 'W': w}, noise_dimensions=noise_dimensions)
    return node._out

wireframe(size=None, use_pixel_size=False) classmethod

Node Wireframe

Parameters:

Name	Type	Description	Default
size	Float	socket 'Size' (id: Size)	None
use_pixel_size	bool	parameter use_pixel_size	False

Returns:

Type	Description
Float

Source code in core/generated/static_snd.py

@classmethod
def wireframe(cls, size: Float = None, use_pixel_size = False):
    """ > Node Wireframe

    Parameters
    ----------
    size : Float, optional
        socket 'Size' (id: Size)

    use_pixel_size : bool
        parameter `use_pixel_size`


    Returns
    -------
    Float
    """
    node = Node('Wireframe', {'Size': size}, use_pixel_size=use_pixel_size)
    return node._out

world_output(surface=None, volume=None, is_active_output=True, target='ALL') classmethod

Node World Output

Parameters:

Name	Type	Description	Default
surface	Shader	socket 'Surface' (id: Surface)	None
volume	VolumeShader	socket 'Volume' (id: Volume)	None
is_active_output	bool	parameter is_active_output	True
target	Literal['All', 'EEVEE', 'Cycles']	parameter target	'ALL'

Returns:

Type	Description
None

Source code in core/generated/static_snd.py

@classmethod
def world_output(cls,
                surface: Shader = None,
                volume: VolumeShader = None,
                is_active_output = True,
                target: Literal['ALL', 'EEVEE', 'CYCLES'] = 'ALL'):
    """ > Node World Output

    Parameters
    ----------
    surface : Shader, optional
        socket 'Surface' (id: Surface)

    volume : VolumeShader, optional
        socket 'Volume' (id: Volume)

    is_active_output : bool
        parameter `is_active_output`

    target : Literal['All', 'EEVEE', 'Cycles']
        parameter `target`


    Returns
    -------
    None
    """
    utils.check_enum_arg('World Output', 'target', target, 'world_output', ('ALL', 'EEVEE', 'CYCLES'))
    node = Node('World Output', {'Surface': surface, 'Volume': volume}, is_active_output=is_active_output, target=target)
    return node._out