PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use NodeTreeInterfaceSocketInt(NodeTreeInterfaceSocket) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeTreeInterfaceSocketInt(NodeTreeInterfaceSocket)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`NodeTreeInterfaceItem`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem "bpy.types.NodeTreeInterfaceItem"), [`NodeTreeInterfaceSocket`](bpy.types.NodeTreeInterfaceSocket.html#bpy.types.NodeTreeInterfaceSocket "bpy.types.NodeTreeInterfaceSocket")

*class* bpy.types.NodeTreeInterfaceSocketInt(*NodeTreeInterfaceSocket*)
:   Integer number socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   int in [-inf, inf], default 0

    max_value
    :   Maximum value

        Type:
        :   int in [-inf, inf], default 0

    min_value
    :   Minimum value

        Type:
        :   int in [-inf, inf], default 0

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Bpy.Types.Greasepenciloffsetmodifier and how is it used in Blender Python scripting?

assistant: difier.invert_material_pass_filter GreasePencilOffsetModifier.invert_vertex_group GreasePencilOffsetModifier.layer_pass_filter GreasePencilOffsetModifier.location GreasePencilOffsetModifier.material_filter GreasePencilOffsetModifier.material_pass_filter GreasePencilOffsetModifier.offset_mode GreasePencilOffsetModifier.open_general_panel GreasePencilOffsetModifier.open_influence_panel GreasePencilOffsetModifier.rotation GreasePencilOffsetModifier.scale GreasePencilOffsetModifier.seed GreasePencilOffsetModifier.stroke_location GreasePencilOffsetModifier.stroke_rotation GreasePencilOffsetModifier.stroke_scale GreasePencilOffsetModifier.stroke_start_offset GreasePencilOffsetModifier.stroke_step GreasePencilOffsetModifier.tree_node_filter GreasePencilOffsetModifier.use_layer_group_filter GreasePencilOffsetModifier.use_layer_pass_filter GreasePencilOffsetModifier.use_material_pass_filter GreasePencilOffsetModifier.use_uniform_random_scale GreasePencilOffsetModifier.vertex_group_name GreasePencilOffsetModifier.bl_rna_get_subclass() GreasePencilOffsetModifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Give a detailed overview of Motion Tracking & Masking: syntax, arguments, return values, common patterns.

assistant: # Motion Tracking & Masking

You perform masking and tracking with the Movie Clip Editor.

[image reference removed]

The Movie Clip Editor.

See [Movie Clip Editor](../editors/clip/index.xhtml) for more information on the Movie Clip Editor.
user: How do I use Index of Nearest in Blender? Include parameters, examples, warnings and best practices.

assistant: # Index of Nearest

[image reference removed]

The **Index of Nearest** node is a way to find other close elements in the same geometry.
If needed you can use Group ID to determine the group of neighbors to be analyzed together.

This is an alternative to the [Sample Nearest Node](sample_nearest.xhtml) node.
The main difference is that this node does not require a geometry input, because the geometry
from the [field context](../../fields.xhtml#field-context) is used.
user: Explain Example in complete detail according to the official Blender documentation.

assistant: This example shows the usage of distance from a target object to dynamically control
a [Wave](../deform/wave.html) modifier with a modified vertex group:

[The blend-file](https://archive.blender.org/wiki/2015/index.php/File:ManModifiersWeightVGroupEx.blend),
TEST_1 scene.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Geometry
:   Standard geometry input.

Selection
:   The selection of elements to sort, if left blank, all elements are sorted.
    Non-selected elements will keep their current indices.

Group ID
:   Elements with the same group ID are sorted together.
    If this is not a field, the node has no effect.

Sort Weight
:   The sorted values used to do the reordering.
    If this is not a field, the node has no effect.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`ShaderNodeTexBrick.texture_mapping`](bpy.types.ShaderNodeTexBrick.html#bpy.types.ShaderNodeTexBrick.texture_mapping "bpy.types.ShaderNodeTexBrick.texture_mapping") - [`ShaderNodeTexChecker.texture_mapping`](bpy.types.ShaderNodeTexChecker.html#bpy.types.ShaderNodeTexChecker.texture_mapping "bpy.types.ShaderNodeTexChecker.texture_mapping") - [`ShaderNodeTexEnvironment.texture_mapping`](bpy.types.ShaderNodeTexEnvironment.html#bpy.types.ShaderNodeTexEnvironment.texture_mapping "bpy.types.ShaderNodeTexEnvironment.texture_mapping") - [`ShaderNodeTexGabor.texture_mapping`](bpy.types.ShaderNodeTexGabor.html#bpy.types.ShaderNodeTexGabor.texture_mapping "bpy.types.ShaderNodeTexGabor.texture_mapping") - [`ShaderNodeTexGradient.texture_mapping`](bpy.types.ShaderNodeTexGradient.html#bpy.types.ShaderNodeTexGradient.texture_mapping "bpy.types.ShaderNodeTexGradient.texture_mapping") - [`ShaderNodeTexImage.texture_mapping`](bpy.types.ShaderNodeTexImage.html#bpy.types.ShaderNodeTexImage.texture_mapping "bpy.types.ShaderNodeTexImage.texture_mapping") | - [`ShaderNodeTexMagic.texture_mapping`](bpy.types.ShaderNodeTexMagic.html#bpy.types.ShaderNodeTexMagic.texture_mapping "bpy.types.ShaderNodeTexMagic.texture_mapping") - [`ShaderNodeTexNoise.texture_mapping`](bpy.types.ShaderNodeTexNoise.html#bpy.types.ShaderNodeTexNoise.texture_mapping "bpy.types.ShaderNodeTexNoise.texture_mapping") - [`ShaderNodeTexSky.texture_mapping`](bpy.types.ShaderNodeTexSky.html#bpy.types.ShaderNodeTexSky.texture_mapping "bpy.types.ShaderNodeTexSky.texture_mapping") - [`ShaderNodeTexVoronoi.texture_mapping`](bpy.types.ShaderNodeTexVoronoi.html#bpy.types.ShaderNodeTexVoronoi.texture_mapping "bpy.types.ShaderNodeTexVoronoi.texture_mapping") - [`ShaderNodeTexWave.texture_mapping`](bpy.types.ShaderNodeTexWave.html#bpy.types.ShaderNodeTexWave.texture_mapping "bpy.types.ShaderNodeTexWave.texture_mapping") |
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`EnumProperty.enum_items`](bpy.types.EnumProperty.html#bpy.types.EnumProperty.enum_items "bpy.types.EnumProperty.enum_items") - [`EnumProperty.enum_items_static`](bpy.types.EnumProperty.html#bpy.types.EnumProperty.enum_items_static "bpy.types.EnumProperty.enum_items_static") - [`EnumProperty.enum_items_static_ui`](bpy.types.EnumProperty.html#bpy.types.EnumProperty.enum_items_static_ui "bpy.types.EnumProperty.enum_items_static_ui") | - [`KeyMap.modal_event_values`](bpy.types.KeyMap.html#bpy.types.KeyMap.modal_event_values "bpy.types.KeyMap.modal_event_values") - [`Struct.property_tags`](bpy.types.Struct.html#bpy.types.Struct.property_tags "bpy.types.Struct.property_tags") |
user: Show practical ways to work with Realizing Instances in a Blender add-on or script – include code.

assistant: The term “realizing” instances referes to converting the instances into unique geometry.
When instances are realized they will take up more memory and manipulation to geometry
will have to be processed individually rather the once per instancing geometry.

To realize instance use the [Realize Instances Node](instances/realize_instances.xhtml).
user: Describe Add/Subtract Brushes from the Blender manual or Python API, including usage steps and snippets.

assistant: These brushes generally push vertices outwards and inwards and are the most customizable to achieve a wide variety of
effects. They typically don’t use a color in their thumbnail.

[image reference removed]

Draw
:   Brush Type: [Draw](draw.html)

    Shortcut: `V`

    The standard brush for pushing vertices inwards and outwards from the surface direction.

Draw Sharp
:   Brush Type: [Draw Sharp](draw_sharp.html)

    Shortcut: `Shift` `V`

    Same as *Draw* but with a much sharper [Falloff](../../brush/falloff.html).
    Useful for creating creases and sharp angles.

Clay
:   Brush Type: [Clay](clay.html)

    Similar to the *Draw* brush but with a flattening effect and subtle smoothing.
    Useful for polishing and building volumes.

Clay Strips
:   Brush Type: [Clay Strips](clay_strips.html)

    Shortcut: `C`

    The same as the *Clay* brush, but more aggressive with a square falloff.
    A common standard for building rough volumes.

Clay Thumb
:   Brush Type: [Clay Thumb](clay_thumb.html)

    The same as the *Clay* brush, but specifically for emulating the effect of running your thumb over surfaces.
    Pushes geometry in and sideways.

Layer
:   Brush Type: [Layer](layer.html)

    Draw with a fixed height. Useful for adding flat layers to a surface.

Inflate/Deflate
:   Brush Type: [Inflate](inflate.html)

    Shortcut: `I`

    Moves the mesh in multiple direction. Useful for inflating or shrinking surfaces and volumes.

Blob
:   Brush Type: [Blob](blob.html)

    Magnifies the mesh as you draw. Useful for an additional inflation effect on the stroke.

Crease Polish
:   Brush Type: [Crease](crease.html)

    Shortcut: `Shift` `C`

    A Draw brush with a pinching effect. Useful for polishing existing creases or carefully creating new ones.

Crease Sharp
:   Brush Type: [Crease](crease.html)

    Much sharper and stronger Crease brush. Great for creating thin and deep pinches.
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

A Surface is a smooth sheet that’s defined by a set of control points.
It’s an extension of a [Curve](../curves/introduction.xhtml),
which is a smooth line.

[image reference removed]

Surface in Edit Mode.

The control points are arranged in a grid with yellow lines indicating
the rows (U direction) and pink lines the columns (V direction).
The surface can be open or closed (cyclic) in either or both directions,
which allows the creation of, say, a cylinder or a sphere.

A Surface can be converted to a mesh using the menu item
Object ‣ Convert ‣ Mesh or the context menu item
Convert To ‣ Mesh.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`CacheFile.active_index`](bpy.types.CacheFile.html#bpy.types.CacheFile.active_index "bpy.types.CacheFile.active_index") | - [`CacheFile.object_paths`](bpy.types.CacheFile.html#bpy.types.CacheFile.object_paths "bpy.types.CacheFile.object_paths") |
user: Explain Sampling in complete detail according to the official Blender documentation.

assistant: # Sampling

The *Sampling* modifier changes the definition, precision of the stroke,
for the following modifiers.

Sampling
:   The smaller this value, the more precise are the strokes.
    Be careful; too small values will require a huge amount of time and memory during render!
user: Describe XrActionMapBindings(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # XrActionMapBindings(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.XrActionMapBindings(*bpy_struct*)
:   Collection of XR action map bindings

    new(*name*, *replace_existing*)
    :   new

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – Name of the action map binding
            - **replace_existing** (*boolean*) – Replace Existing, Replace any existing binding with the same name

        Returns:
        :   Binding, Added action map binding

        Return type:
        :   [`XrActionMapBinding`](bpy.types.XrActionMapBinding.html#bpy.types.XrActionMapBinding "bpy.types.XrActionMapBinding")

    new_from_binding(*binding*)
    :   new_from_binding

        Parameters:
        :   **binding** ([`XrActionMapBinding`](bpy.types.XrActionMapBinding.html#bpy.types.XrActionMapBinding "bpy.types.XrActionMapBinding"), (never None)) – Binding, Binding to use as a reference

        Returns:
        :   Binding, Added action map binding

        Return type:
        :   [`XrActionMapBinding`](bpy.types.XrActionMapBinding.html#bpy.types.XrActionMapBinding "bpy.types.XrActionMapBinding")

    remove(*binding*)
    :   remove

        Parameters:
        :   **binding** ([`XrActionMapBinding`](bpy.types.XrActionMapBinding.html#bpy.types.XrActionMapBinding "bpy.types.XrActionMapBinding"), (never None)) – Binding

    find(*name*)
    :   find

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Binding, The action map binding with the given name

        Return type:
        :   [`XrActionMapBinding`](bpy.types.XrActionMapBinding.html#bpy.types.XrActionMapBinding "bpy.types.XrActionMapBinding")

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Transform: syntax, arguments, return values, common patterns.

assistant: You can move the selected node(s) by clicking and dragging any empty part of them.
Alternatively, press `G`, move the mouse, and click `LMB` to confirm.

Dragging a node on top of an existing link will intelligently insert the selected node into the link path.
This generally uses the first socket that matches the link type.
The automatic node attachment feature can be toggled with `Alt`.
When a node is automatically attached, the surrounding nodes
will be offset to the right or left depending on the `T` toggle;
see [Auto-Offset](arranging.html#editors-nodes-usage-auto-offset) for more information.

While dragging nodes, you can press `F` to toggle their parent [Frame](types/layout/frame.html):

- If the nodes are inside a frame, they will be detached from it.
- If the nodes are not inside a frame and there is a frame under the cursor, they will be attached to that frame.

In general, it is recommended to arrange your nodes so that data flows from left to right, top to bottom.

The width of a node can be changed by dragging its left or right border.

Rotating (`R`) and scaling (`S`) only apply when multiple nodes are selected,
and only affect their positions.
user: Provide the full official documentation entry for Event Direction Items, preserving all code examples.

assistant: # Event Direction Items

ANY:
:   Any.

NORTH:
:   North.

NORTH_EAST:
:   North-East.

EAST:
:   East.

SOUTH_EAST:
:   South-East.

SOUTH:
:   South.

SOUTH_WEST:
:   South-West.

WEST:
:   West.

NORTH_WEST:
:   North-West.
user: Show practical ways to work with Add Constraint (with Targets) in a Blender add-on or script – include code.

assistant: Adds a constraint to the active object.
The type of constraint must be chosen from a pop-up menu,
though it can be changed later from the *Add Constraint (with Targets)*
[Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.
If there is an other object selected besides the active one,
that object will be the constraint target (if the chosen constraint accepts targets).

When using a bone from another armature as the target for a constraint, the tool
will look inside the non-active armature and use its active bone,
provided that armature is in Pose Mode.
user: Explain Data Transfer Modifier in complete detail according to the official Blender documentation.

assistant: # Data Transfer Modifier

The *Data Transfer* modifier copies certain types of data from an external mesh
to the modified one. This could be [UV maps](../../../editors/uv/introduction.html),
[color attributes](../../meshes/properties/object_data.html#modeling-meshes-properties-object-data-color-attributes),
[custom normals](../../meshes/structure.html#modeling-meshes-normals-custom), and so on.

For each element (vertex/edge/face) in the modified mesh, the modifier finds one
or more matching elements in the source mesh, then interpolates between those source
elements’ values.

[image reference removed]

Transferring a UV map from a low resolution mesh to a high resolution one
using interpolation.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: String
:   The input string to be evaluated.

Operation
:   Determines how the input string is compared to the key:

    Starts With:
    :   True if the input string begins with the key.

    Ends With:
    :   True if the input string ends with the key.

    Contains:
    :   True if the input string contains the key anywhere within it.

Key
:   The target string to compare against.
user: Explain Editing in complete detail according to the official Blender documentation.

assistant: The following operations are available in the file list’s context menu.

External
:   Use the operating system to perform an action on the file or directory.
    The options listed below might not be available on all operating systems.

    Open:
    :   Open the file.

    Open Folder:
    :   Open the folder.

    Edit:
    :   Edit the file.

    New:
    :   Create a new file of this type.

    Find File:
    :   Search for files of this type.

    Show:
    :   Show this file.

    Play:
    :   Play this file.

    Browse:
    :   Browse this file.

    Preview:
    :   Preview this file.

    Print:
    :   Print this file.

    Install:
    :   Install this file.

    Run As User:
    :   Run as specific user.

    Properties:
    :   Show OS Properties for this item.

    Find in Folder:
    :   Search for items in this folder.

    Command Prompt Here:
    :   Open a command prompt here.

Delete `Delete`, `X`
:   Delete the currently selected files or directories by moving them to the operating system’s “trash”.

    Note, on Linux deleting directories requires KDE or GNOME.

Rename `F2`
:   Change the name of the currently selected file or directory.
user: Explain TextureNodeScale(TextureNode) in complete detail according to the official Blender documentation.

assistant: # TextureNodeScale(TextureNode)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), [`NodeInternal`](bpy.types.NodeInternal.html#bpy.types.NodeInternal "bpy.types.NodeInternal"), [`TextureNode`](bpy.types.TextureNode.html#bpy.types.TextureNode "bpy.types.TextureNode")

*class* bpy.types.TextureNodeScale(*TextureNode*)
:   *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

    *classmethod* input_template(*index*)
    :   Input socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

        Return type:
        :   [`NodeInternalSocketTemplate`](bpy.types.NodeInternalSocketTemplate.html#bpy.types.NodeInternalSocketTemplate "bpy.types.NodeInternalSocketTemplate")

    *classmethod* output_template(*index*)
    :   Output socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

        Return type:
        :   [`NodeInternalSocketTemplate`](bpy.types.NodeInternalSocketTemplate.html#bpy.types.NodeInternalSocketTemplate "bpy.types.NodeInternalSocketTemplate")

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Usage from the Blender manual or Python API, including usage steps and snippets.

assistant: - Use the *Shape Key Editor* to keyframe shape key influences over time.
- Adjust timing by moving or scaling keyframes directly in the timeline.
- Combine with other Dope Sheet modes (such as the *Action Editor*) for complex character animation workflows.

See also: [Shape Key Basics](../../../animation/shape_keys/introduction.xhtml) for details on creating
and managing shape keys.
user: Explain Example in complete detail according to the official Blender documentation.

assistant: In the example below, the left and right cubes are assigned a *Pass Index* of 1 and 2 respectively.
We extract a mask for the left cube, then use it to turn that cube red with a
[Mix Color Node](../color/mix_color.xhtml). The masks for the other Pass Indexes are also shown.

[image reference removed]

ID Mask node example.
user: Explain GeometryNodeMeshToCurve(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeMeshToCurve(GeometryNode)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), [`NodeInternal`](bpy.types.NodeInternal.html#bpy.types.NodeInternal "bpy.types.NodeInternal"), [`GeometryNode`](bpy.types.GeometryNode.html#bpy.types.GeometryNode "bpy.types.GeometryNode")

*class* bpy.types.GeometryNodeMeshToCurve(*GeometryNode*)
:   Generate a curve from a mesh

    mode
    :   - `EDGES`
          Edges – Convert mesh edges to curve segments. Attributes are propagated to curve points..
        - `FACES`
          Faces – Convert each mesh face to a cyclic curve. Face attributes are propagated to curves..

        Type:
        :   enum in [`'EDGES'`, `'FACES'`], default `'EDGES'`

    *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

    *classmethod* input_template(*index*)
    :   Input socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

        Return type:
        :   [`NodeInternalSocketTemplate`](bpy.types.NodeInternalSocketTemplate.html#bpy.types.NodeInternalSocketTemplate "bpy.types.NodeInternalSocketTemplate")

    *classmethod* output_template(*index*)
    :   Output socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

        Return type:
        :   [`NodeInternalSocketTemplate`](bpy.types.NodeInternalSocketTemplate.html#bpy.types.NodeInternalSocketTemplate "bpy.types.NodeInternalSocketTemplate")

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Installing Blender in complete detail according to the official Blender documentation.

assistant: Blender downloads can be extracted to any directory on the system, as
a self contained installation. Multiple Blender versions can
co-exist on the same system, and deployment can be automated using
standard file management tools.

New Blender versions may add, remove or change functionality that
affects the results of production files. For a given project, it is
advisable to use a single LTS version
of Blender. LTS versions receive bug fixes for two years.
user: Provide the full official documentation entry for LineStyleColorModifier_Noise(LineStyleColorModifier), preserving all code examples.

assistant: # LineStyleColorModifier_Noise(LineStyleColorModifier)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`LineStyleModifier`](bpy.types.LineStyleModifier.html#bpy.types.LineStyleModifier "bpy.types.LineStyleModifier"), [`LineStyleColorModifier`](bpy.types.LineStyleColorModifier.html#bpy.types.LineStyleColorModifier "bpy.types.LineStyleColorModifier")

*class* bpy.types.LineStyleColorModifier_Noise(*LineStyleColorModifier*)
:   Change line color based on random noise

    amplitude
    :   Amplitude of the noise

        Type:
        :   float in [-inf, inf], default 0.0

    blend
    :   Specify how the modifier value is blended into the base value

        Type:
        :   enum in [Ramp Blend Items](bpy_types_enum_items/ramp_blend_items.html#rna-enum-ramp-blend-items), default `'MIX'`

    color_ramp
    :   Color ramp used to change line color

        Type:
        :   [`ColorRamp`](bpy.types.ColorRamp.html#bpy.types.ColorRamp "bpy.types.ColorRamp"), (readonly)

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

        Type:
        :   float in [0, 1], default 0.0

    period
    :   Period of the noise

        Type:
        :   float in [-inf, inf], default 0.0

    seed
    :   Seed for the noise generation

        Type:
        :   int in [1, 32767], default 0

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Color Modifier Type Items](bpy_types_enum_items/linestyle_color_modifier_type_items.html#rna-enum-linestyle-color-modifier-type-items), default `'ALONG_STROKE'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleColorModifier_Noise.type "bpy.types.LineStyleColorModifier_Noise.type")
user: Describe FunctionNodeMatrixMultiply(FunctionNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # FunctionNodeMatrixMultiply(FunctionNode)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), [`NodeInternal`](bpy.types.NodeInternal.html#bpy.types.NodeInternal "bpy.types.NodeInternal"), [`FunctionNode`](bpy.types.FunctionNode.html#bpy.types.FunctionNode "bpy.types.FunctionNode")

*class* bpy.types.FunctionNodeMatrixMultiply(*FunctionNode*)
:   Perform a matrix multiplication on two input matrices

    *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

    *classmethod* input_template(*index*)
    :   Input socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

        Return type:
        :   [`NodeInternalSocketTemplate`](bpy.types.NodeInternalSocketTemplate.html#bpy.types.NodeInternalSocketTemplate "bpy.types.NodeInternalSocketTemplate")

    *classmethod* output_template(*index*)
    :   Output socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

        Return type:
        :   [`NodeInternalSocketTemplate`](bpy.types.NodeInternalSocketTemplate.html#bpy.types.NodeInternalSocketTemplate "bpy.types.NodeInternalSocketTemplate")

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: ### Manual Z-Mask

[image reference removed]

Minimum and maximum function example.

The top *Render Layers* node has a cube that is about 10 units from the camera.
The bottom *Render Layers* node has a plane that covers the left half of the view
and is 7 units from the camera.
Both are fed through their respective *Map Value* nodes to multiply the depth value by
0.05 and clamp it to [0.0, 1.0], bringing it into a suitable range for displaying it as a color.

The Minimum node selects the smallest of the two depth values at each pixel. In the left half,
it chooses the plane (because it’s closer than the cube), and in the right half,
it chooses the cube (because it’s closer than the background, which is infinitely far away).

The Maximum node selects the largest of the two depth values at each pixel. In the left half,
it chooses the cube (because it’s farther away than the plane), and in the right half,
it chooses the background (because it’s farther away than the cube).

### Using Sine Function to Pulsate

[image reference removed]

Using sine function example.

This example has a *Time* node putting out a linear sequence from 0 to 1 over the course of 101 frames.
At frame 25, the output value is 0.25.
That value is multiplied by 2 × pi (6.28) and converted to 1.0 by the Sine function,
since \(sin(2 × pi/ 4) = sin(pi/ 2) = +1.0\).

Since the sine function can output values between (-1.0 to 1.0),
the *Map Value* node scales that to 0.0 to 1.0 by taking the input (-1 to 1), adding 1
(making 0 to 2), and multiplying the result by 0.5 (thus scaling the output between 0 to 1).
The default *Color Ramp* converts those values to a gray-scale.
Thus, medium gray corresponds to a 0.0 output by the sine, black to -1.0,
and white to 1.0. As you can see, \(sin(pi/ 2) = 1.0\). Like having your own visual color calculator!
Animating this node setup provides a smooth cyclic sequence through the range of grays.

Use this function to vary, for example,
the alpha channel of an image to produce a fading in/out effect.
Alter the Z channel to move a scene in/out of focus.
Alter a color channel value to make a color “pulse”.

### Brightening (Scaling) a Channel

[image reference removed]

Scaling a channel example.

This example has a *Math (Multiply)* node increasing the luminance channel (Y)
of the image to make it brighter. Note that you should use a *Map Value node*
with min() and max() enabled to clamp the output to valid values.
With this approach, you could use a logarithmic function to make a high dynamic range image.
For this particular example,
there is also a *Brightness/Contrast node* that might give simpler control over brightness.
user: Describe Pull Requests and Reviews from the Blender manual or Python API, including usage steps and snippets.

assistant: When you commit your changes, they are sent as a pull request for review by the documentation team.
Reviewers may suggest improvements or request additional changes.

Once your pull request is approved, a reviewer will merge it, and your contribution will be published online.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Next Vertex Index
:   The following vertex on the shortest path from every vertex to the closest endpoint
    (as defined by the cost input).

Total Cost
:   The remaining cost before an end vertex is reached.
user: Provide the full official documentation entry for Mask Data-block, preserving all code examples.

assistant: Mask data-block containing multiple mask layers and splines.
They are the most high-level entities used for masking purposes.
Masks can be reused in different places, and hold global parameters for all the entities they consist of.
user: What is Bpy.Types.Voronoitexture and how is it used in Blender Python scripting?

assistant: 9; Blender Authors Made with Furo Report issue on this page On this page VoronoiTexture(Texture) VoronoiTexture VoronoiTexture.color_mode VoronoiTexture.distance_metric VoronoiTexture.minkovsky_exponent VoronoiTexture.nabla VoronoiTexture.noise_intensity VoronoiTexture.noise_scale VoronoiTexture.weight_1 VoronoiTexture.weight_2 VoronoiTexture.weight_3 VoronoiTexture.weight_4 VoronoiTexture.users_material VoronoiTexture.users_object_modifier VoronoiTexture.bl_rna_get_subclass() VoronoiTexture.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Describe ColorBalanceModifier(StripModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ColorBalanceModifier(StripModifier)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`StripModifier`](bpy.types.StripModifier.html#bpy.types.StripModifier "bpy.types.StripModifier")

*class* bpy.types.ColorBalanceModifier(*StripModifier*)
:   Color balance modifier for sequence strip

    color_balance
    :   Type:
        :   [`StripColorBalanceData`](bpy.types.StripColorBalanceData.html#bpy.types.StripColorBalanceData "bpy.types.StripColorBalanceData"), (readonly)

    color_multiply
    :   Multiply the intensity of each pixel

        Type:
        :   float in [0, 20], default 1.0

    open_mask_input_panel
    :   Type:
        :   boolean, default False

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Index: syntax, arguments, return values, common patterns.

assistant: # Index

[**Symbols**](#Symbols) | [**A**](#A) | [**B**](#B) | [**C**](#C) | [**D**](#D) | [**E**](#E) | [**F**](#F) | [**G**](#G) | [**H**](#H) | [**I**](#I) | [**K**](#K) | [**L**](#L) | [**M**](#M) | [**N**](#N) | [**O**](#O) | [**P**](#P) | [**Q**](#Q) | [**R**](#R) | [**S**](#S) | [**T**](#T) | [**U**](#U) | [**V**](#V) | [**W**](#W) | [**Z**](#Z)
user: Show practical ways to work with Applications in a Blender add-on or script – include code.

assistant: Image Editor
:   The path to an external program to use for image editing.

Animation Player
:   The program used for playing back rendered animations via
    [View Animation](../../interface/window_system/topbar.html#topbar-render-view-animation).

    By default this is set to *Internal* which uses Blender’s built-in
    [animation player](../../render/output/animation_player.html#bpy-ops-render-play-rendered-anim).

    This has the advantage that all image formats supported by Blender can be played back
    and no 3rd party application needs to be installed.

### Text Editor

Program
:   Command to launch the text editor when using [Edit Externally](../text_editor.html#bpy-ops-text-jump-to-file-at-point),
    either a full path or a command in `$PATH`. Use the internal editor when left blank.

Arguments
:   Defines the specific format of the arguments with which the text editor opens files.

    The supported expansions are as follows:

    - `$filepath`: The absolute path of the file.
    - `$line`: The line to open at (Optional).
    - `$column`: The column to open from the beginning of the line (Optional).
    - `$line0` & `$column0` similar to the above but they start at zero.

    Example: `-f $filepath -l $line -c $column`
user: What is Rotate Rotation Node and how is it used in Blender Python scripting?

assistant: # Rotate Rotation Node

[image reference removed]

The *Rotate Rotation* node applies an additional rotation to a given one.

To rotate an [Euler Rotation](../../../../glossary/index.xhtml#term-Euler-Rotation), first use the
[Euler to Rotation Node](euler_to_rotation.xhtml).
user: Provide the full official documentation entry for Troubleshoot an Override Hierarchy, preserving all code examples.

assistant: These operations are only available from the Outliner contextual menu. They can help fixing a broken
override hierarchy.

### Resync

The hierarchy of the linked data (the relationships between linked data-blocks) can change.
Overrides need to be resynced to match the new hierarchy. This operator will resync the override
to match the new hierarchy in the library.

### Resync Enforce

In some cases, especially with older blend-files that were saved with ‘broken’ (non-hierarchy-matching) overrides,
a regular resync itself cannot rebuild properly the override as expected (e.g. some objects might go missing).
To solve this issue, this operator rebuilds the local override from its linked reference,
as well as its hierarchy of dependencies, enforcing that hierarchy to match the linked data
(i.e. ignoring existing overrides on data-blocks properties).
This is similar to a regular resync, but is more forceful, aggressive,
at the cost of a potential loss of some overrides on ID pointers properties.

### Delete

Remove the whole library override hierarchy, and replace all of these override data-blocks by
their original linked data-blocks. This fully reverts the *Make* operation.
user: Give a detailed overview of Rigid Body Properties: syntax, arguments, return values, common patterns.

assistant: # Rigid Body Properties

Type
:   Role of the rigid body in the simulation.

    Active:
    :   The object is dynamic and is directly controlled by simulation results.

    Passive:
    :   The object remains static and is directly controlled by animation system,
        thus does not have [Dynamics](dynamics.html) properties.
user: Describe SplineBezierPoints(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # SplineBezierPoints(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.SplineBezierPoints(*bpy_struct*)
:   Collection of spline Bézier points

    add(*count*)
    :   Add a number of points to this spline

        Parameters:
        :   **count** (*int in* *[**0**,* *inf**]*) – Number, Number of points to add to the spline

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Image
:   The input image with the vignette effect applied.

Mask
:   The generated vignette mask as a grayscale output.
    This can be used for custom compositing or to apply the vignette selectively through mix nodes.
user: How do I use Scenes as Assets in Blender? Include parameters, examples, warnings and best practices.

assistant: Scenes can also be marked and used as [Assets](../../files/asset_libraries/index.xhtml).
This allows them to appear in the [Asset Browser](../../editors/asset_browser.xhtml) for reuse across projects.

Scene assets are a convenient way to manage pre-built scene templates, lighting rigs, or shot setups.
They store all relevant data (such as cameras, lights, and render settings) and can be dragged into any open Blender file.

When a scene asset is dragged into another window (except the Asset Browser itself),
Blender performs one of the following actions:

- **Link or Append:** Imports the scene into the current blend-file as a linked or appended data-block.
- **Activate:** Sets the imported (or linked) scene as the *active* one in the window.

Scene assets generate preview images automatically by rendering from the active camera in *Solid View* mode.
For this to work, the scene must contain an active camera.

Typical uses for scene assets include:

- Creating reusable lighting or studio setups.
- Storing shot layouts for multi-shot projects.
- Maintaining consistent render settings across files.
- Building base templates for new projects or departments.
user: How do I use LineStyleThicknessModifier_AlongStroke(LineStyleThicknessModifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # LineStyleThicknessModifier_AlongStroke(LineStyleThicknessModifier)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`LineStyleModifier`](bpy.types.LineStyleModifier.html#bpy.types.LineStyleModifier "bpy.types.LineStyleModifier"), [`LineStyleThicknessModifier`](bpy.types.LineStyleThicknessModifier.html#bpy.types.LineStyleThicknessModifier "bpy.types.LineStyleThicknessModifier")

*class* bpy.types.LineStyleThicknessModifier_AlongStroke(*LineStyleThicknessModifier*)
:   Change line thickness along stroke

    blend
    :   Specify how the modifier value is blended into the base value

        Type:
        :   enum in [`'MIX'`, `'ADD'`, `'SUBTRACT'`, `'MULTIPLY'`, `'DIVIDE'`, `'DIFFERENCE'`, `'MINIMUM'`, `'MAXIMUM'`], default `'MIX'`

    curve
    :   Curve used for the curve mapping

        Type:
        :   [`CurveMapping`](bpy.types.CurveMapping.html#bpy.types.CurveMapping "bpy.types.CurveMapping"), (readonly)

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

        Type:
        :   float in [0, 1], default 0.0

    invert
    :   Invert the fade-out direction of the linear mapping

        Type:
        :   boolean, default False

    mapping
    :   Select the mapping type

        - `LINEAR`
          Linear – Use linear mapping.
        - `CURVE`
          Curve – Use curve mapping.

        Type:
        :   enum in [`'LINEAR'`, `'CURVE'`], default `'LINEAR'`

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Thickness Modifier Type Items](bpy_types_enum_items/linestyle_thickness_modifier_type_items.html#rna-enum-linestyle-thickness-modifier-type-items), default `'ALONG_STROKE'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

    value_max
    :   Maximum output value of the mapping

        Type:
        :   float in [-inf, inf], default 0.0

    value_min
    :   Minimum output value of the mapping

        Type:
        :   float in [-inf, inf], default 0.0

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleThicknessModifier_AlongStroke.type "bpy.types.LineStyleThicknessModifier_AlongStroke.type")
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

UI for a Turbulence force field.

Size
:   Indicates the scale of the noise.

Global
:   Makes the size and strength of the noise relative to the world, instead of the object it is attached to.
user: Provide the full official documentation entry for Face Corner Angle Node, preserving all code examples.

assistant: # Face Corner Angle Node

[image reference removed]

The *Face Corner Angle* node outputs geometric information about the angle at each face corner
of a mesh. It can be used to analyze the shape of polygons, detect sharp corners, or create
procedural effects based on corner geometry.
user: Give a detailed overview of Follow Active Quads: syntax, arguments, return values, common patterns.

assistant: Starts from the active quad and recursively attaches its neighboring, selected mesh quads to its
pre-existing UV quad. Non-quad faces are ignored.

### Options

The [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel allows fine control over how the mesh is unwrapped:

Edge Length Mode
:   How to calculate the lengths of the UV edges for the newly attached quads.

    Even
    :   Give each new UV edge the same length as the UV edge it’s extending,
        regardless of its length on the mesh.

    Length
    :   Give each new UV edge a length that’s proportional to its length on the mesh.

    Length Average
    :   Give each new UV edge a length that’s proportional to the average edge length
        in its [edge ring](../selecting/loops.xhtml#modeling-meshes-selecting-edge-rings) on the mesh.
user: Provide the full official documentation entry for Array Modifier, preserving all code examples.

assistant: # Array Modifier

The *Array* modifier creates multiple copies of an input geometry and arranges them in
a linear, circular, or custom pattern. It offers flexible options for count, spacing,
and randomization, allowing for both precise and organic duplication of geometry.