PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: ID Value
:   Input for the *Object Index* or *Material Index* render pass.
    Once a pass is enabled, it can be accessed through the *IndexOB* or *IndexMA* slot of the
    [Render Layers Node](../input/scene/render_layers.xhtml).

Index
:   The index for which to create a mask. This index can be configured for objects at
    Properties ‣ Object ‣ Relations ‣ Pass Index,
    and for materials at Properties ‣ Material ‣ Settings ‣ Pass Index.

    [image reference removed]

    Object Pass Index.

[Anti-Aliasing](../../../glossary/index.xhtml#term-Anti-Aliasing)
:   Whether to smooth the mask edges.
user: What is Creating a Rigid Body and how is it used in Blender Python scripting?

assistant: Only mesh objects can be part of a rigid body simulation.
To create rigid bodies, either click on the *Rigid Body* button in the *Physics* tab of
the Properties or use *Add Active*/*Add Passive* in the Object ‣ Rigid Body menu.

There are two types of rigid bodies: active and passive. *Active* bodies are dynamically simulated, while *passive*
bodies remain static. Both types can be driven by the animation system when using the *Animated* option.

During the simulation,
the rigid body system will override the position and orientation of dynamic rigid body objects.
Note however, that the location and rotation of the objects are not changed,
so the rigid body simulation acts similar to a constraint.
To apply the rigid body transformations you can use
the *Apply Object Transform* operator.

The scale of the rigid body object also influences the simulation, but is always controlled by the animation system.

Rigid body physics on the object can be *removed* with the *Rigid Body* button
in the *Physics* tab in the Properties or in the Object ‣ Rigid Body menu.
user: Explain Displacement Node in complete detail according to the official Blender documentation.

assistant: # Displacement Node

[image reference removed]

The *Displacement* node is used to displace the surface along the surface normal,
to add more detail to the geometry. Both procedural textures and baked displacement maps
can be used.

By default, Blender only uses [Bump Mapping](../../../glossary/index.xhtml#term-Bump-Mapping) to render displacement.
However with true displacement, the rendered geometry will be physically displaced. To use true displacement
the [Displacement method](../../eevee/material_settings.xhtml#bpy-types-material-displacement-method) must be set accordingly.
user: Describe Multiple Scattering from the Blender manual or Python API, including usage steps and snippets.

assistant: Real-world effects such as scattering in clouds or subsurface scattering require many
scattering bounces. However, unbiased rendering of such effects can be noisy, so by default
the number of bounces is zero in Cycles, and no support is available in EEVEE.
The effect you get when rendering with zero volume bounces is what is known as
“single scattering”, the effect from more bounces is “multiple scattering”.

For rendering materials like skin or milk that require multiple scattering,
subsurface scattering is more efficient and easier to control. Particularly the random walk
method can accurately render such materials.

For materials such as clouds or smoke that do not have a well-defined surface,
volume rendering is required. These look best with many scattering bounces,
but in practice one might have to limit the number of bounces to keep render times acceptable.
user: What is Keys to Samples and how is it used in Blender Python scripting?

assistant: Switches the selected curves from interpolating between a set of keyframes to using
a sampled value at each full frame.
**This is a destructive process that removes the ability to edit the curve.**
It’s mainly used to reduce the file size with large datasets, as samples take up
less space than keyframes.

Between samples (on subframes), the curve interpolates linearly.
user: Provide the full official documentation entry for basic.super_copy, preserving all code examples.

assistant: Single-bone rig type that simply copies the bone. Useful as utility rig type for
adding custom features or specific deform bones to your rigs.

Control (Boolean)
:   When enabled a control bone and widget will be created.

Widget (Boolean)
:   When enabled a widget will be created in replacement to the standard.

Widget Type (String):
:   Allows selecting one of the predefined widget types to generate instead of the default circle.

Deform (Boolean)
:   When enabled a deform bone will be created.

Relink Constraints
:   Works the same as in the [basic.raw_copy](#basic-raw-copy) rig. In addition, when enabled any constraints that have
    names prefixed with `CTRL:` are moved to the control, and with `DEF:` to the deform bone.
user: How do I use CompositorNodeMask(CompositorNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CompositorNodeMask(CompositorNode)

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"), [`CompositorNode`](bpy.types.CompositorNode.html#bpy.types.CompositorNode "bpy.types.CompositorNode")

*class* bpy.types.CompositorNodeMask(*CompositorNode*)
:   Input mask from a mask data-block, created in the image editor

    mask
    :   Type:
        :   [`Mask`](bpy.types.Mask.html#bpy.types.Mask "bpy.types.Mask")

    *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")

    update()

    *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 NodeTreeInterfaceSocketImage(NodeTreeInterfaceSocket) and how is it used in Blender Python scripting?

assistant: # NodeTreeInterfaceSocketImage(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.NodeTreeInterfaceSocketImage(*NodeTreeInterfaceSocket*)
:   Image socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`Image`](bpy.types.Image.html#bpy.types.Image "bpy.types.Image")

    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: How do I use ShaderNodeVolumeScatter(ShaderNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ShaderNodeVolumeScatter(ShaderNode)

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"), [`ShaderNode`](bpy.types.ShaderNode.html#bpy.types.ShaderNode "bpy.types.ShaderNode")

*class* bpy.types.ShaderNodeVolumeScatter(*ShaderNode*)
:   Scatter light as it passes through the volume, often used to add fog to a scene

    phase
    :   Phase function for the scattered light

        - `HENYEY_GREENSTEIN`
          Henyey-Greenstein – Henyey-Greenstein, default phase function for the scattering of light.
        - `FOURNIER_FORAND`
          Fournier-Forand – Fournier-Forand phase function, used for the scattering of light in underwater environments.
        - `DRAINE`
          Draine – Draine phase functions, mostly used for the scattering of light in interstellar dust.
        - `RAYLEIGH`
          Rayleigh – Rayleigh phase function, mostly used for particles smaller than the wavelength of light, such as scattering of sunlight in earth’s atmosphere.
        - `MIE`
          Mie – Approximation of Mie scattering in water droplets, used for scattering in clouds and fog.

        Type:
        :   enum in [`'HENYEY_GREENSTEIN'`, `'FOURNIER_FORAND'`, `'DRAINE'`, `'RAYLEIGH'`, `'MIE'`], default `'HENYEY_GREENSTEIN'`

    *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: Provide the full official documentation entry for Inherited Properties, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleColorModifier.name`](bpy.types.LineStyleColorModifier.html#bpy.types.LineStyleColorModifier.name "bpy.types.LineStyleColorModifier.name") |
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Vector
:   Vector of the input system that is to be divided into radial segments.

Sides
:   Number of radial segments to divide the input coordinate system into.
    A non-integer value results in an irregular segment that is smaller than the regular segments.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_0.png   Sides: 5.0. | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_25.png   Sides: 5.25. | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_5.png   Sides: 5.5. | ../../../../_images/render_shader-nodes_radial_tiling_segments-6_0.png   Sides: 6.0. |

Roundness
:   Roundness of the segment coordinate systems.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_0.png   Roundness: 0.0. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_25.png   Roundness: 0.25. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_5.png   Roundness: 0.5. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-1_0.png   Roundness: 1.0. |
user: Describe NodeTreeInterfaceSocketCollection(NodeTreeInterfaceSocket) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeTreeInterfaceSocketCollection(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.NodeTreeInterfaceSocketCollection(*NodeTreeInterfaceSocket*)
:   Collection socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`Collection`](bpy.types.Collection.html#bpy.types.Collection "bpy.types.Collection")

    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 Tool Settings and how is it used in Blender Python scripting?

assistant: Depth
:   The initial depth (from the screen into the scene) used when placing the object.

    Surface:
    :   Start placing on the surface under the mouse cursor. If there is no surface, this does the
        same as *Cursor Plane*.

    Cursor Plane:
    :   Start placing on a plane that goes through the [3D Cursor](../3d_cursor.xhtml)
        and is aligned according to the *Orientation* and *Plane Axis*.

    Cursor View:
    :   Start placing on a plane that goes through the 3D Cursor and is aligned to the view.

Orientation
:   The new object’s orientation – a set of three axes, out of which *Plane Axis* chooses one.

    Surface:
    :   The object uses the normal orientation of the surface under the mouse cursor.
        If there is no surface, this does the same as *Default*.

    Default:
    :   The object uses the default [Transform Orientation](../controls/orientation.xhtml).

Snap To
:   The target to use while [Snapping](../controls/snapping.xhtml).

    Geometry:
    :   Snap to all types of geometry (vertices, edges, and faces).

    Default:
    :   Snap to the target defined in the global snapping options.

Plane Axis
:   Which of the three *Orientation* axes (X, Y or Z) is “up” for the object.
    The object’s base will be perpendicular to this axis.

Auto Axis
:   Rather than using the *Orientation* axis indicated by *Plane Axis*,
    use the one that’s closest to the viewport’s viewing direction
    (when not hovering over a surface).

Base

Origin
:   How the base is defined.

    Edge:
    :   The base is defined from one corner to the opposing corner.

    Center:
    :   The base is defined from the centerpoint to a corner.

Aspect
:   Whether the base has a free or fixed aspect ratio.

    Free:
    :   The width and depth of the base can be chosen independently.

    Fixed:
    :   The width and depth of the base are forced to be equal.

Height

Origin
:   How the height is defined.

    Edge:
    :   The base becomes the bottom, after which you define the top.

    Center:
    :   The base becomes the center, after which you define the top.

Aspect
:   Whether the object’s side has a free or fixed aspect ratio.

    Free:
    :   The height can be chosen independently of the base.

    Fixed:
    :   The height is forced to be equal to the largest side of the base.
user: How do I use ShaderNodeOutputAOV(ShaderNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ShaderNodeOutputAOV(ShaderNode)

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"), [`ShaderNode`](bpy.types.ShaderNode.html#bpy.types.ShaderNode "bpy.types.ShaderNode")

*class* bpy.types.ShaderNodeOutputAOV(*ShaderNode*)
:   Arbitrary Output Variables.
    Provide custom render passes for arbitrary shader node outputs

    aov_name
    :   Name of the AOV that this output writes to

        Type:
        :   string, default “”, (never None)

    *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: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.tool_settings`](bpy.context.html#bpy.context.tool_settings "bpy.context.tool_settings") - [`Context.tool_settings`](bpy.types.Context.html#bpy.types.Context.tool_settings "bpy.types.Context.tool_settings") | - [`Scene.tool_settings`](bpy.types.Scene.html#bpy.types.Scene.tool_settings "bpy.types.Scene.tool_settings") |
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Performance

[[image reference removed]](../_images/compositing_sidebar_options.png)

Performance panel.

This panel helps you tweak the performance of the Compositor.

Device
:   The device used for compositing.

    CPU:
    :   Use the CPU for compositing.

    GPU:
    :   Use the GPU for compositing.

Precision GPU
:   The precision of compositor intermediate result.

    Auto:
    :   Use full precision for final renders, half precision otherwise.

    Full:
    :   Use full precision for final renders and viewport.

Viewer Region
:   This allows to set an area of interest for the backdrop.
    Press `Ctrl`-`B` and select a rectangular area in the preview
    which will become the next preview in the backdrop.
    `Ctrl`-`Alt`-`B` discards the region back to a full preview.
    This is only a preview option, final compositing during a render ignores this region.
user: How do I use BrushCapabilitiesVertexPaint(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # BrushCapabilitiesVertexPaint(bpy_struct)

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

*class* bpy.types.BrushCapabilitiesVertexPaint(*bpy_struct*)
:   Read-only indications of supported operations

    has_color
    :   Type:
        :   boolean, default False, (readonly)

    *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: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Mode
:   The color model to output.

    RGB:
    :   Split the input image into it’s three outputs: Red, Green, and Blue color channels.

    HSV:
    :   Split the input image into it’s three outputs: Hue, Saturation, and Value color channels.

    HSL:
    :   Split the input image into it’s three outputs: Hue, Saturation, and Lightness color channels.

    YCbCrA:
    :   > Split the input image into it’s three outputs:
        > Luminance, Chrominance Blue, and Chrominance Red color channels.

        Color Space
        :   ITU 601, ITU 709, JPEG

    YUV:
    :   Split the input image into it’s three outputs:
        Luminance, U chrominance, and V chrominance color channels.
user: Show practical ways to work with Batch Creation in a Blender add-on or script – include code.

assistant: Batches can be creates by first manually creating VBOs and IBOs.
However, it is recommended to use the [`gpu_extras.batch.batch_for_shader`](gpu_extras.batch.html#gpu_extras.batch.batch_for_shader "gpu_extras.batch.batch_for_shader") function.
It makes sure that all the vertex attributes necessary for a specific shader are provided.
Consequently, the shader has to be passed to the function as well.
When using this function one rarely has to care about the vertex format, VBOs and IBOs created in the background.
This is still something one should know when drawing stuff though.

Since batches can be drawn multiple times, they should be cached and reused whenever possible.
user: Describe Collapse Edges & Faces from the Blender manual or Python API, including usage steps and snippets.

assistant: Collapse each isolated edge and face region into single vertices,
with support for face data such as UVs and vertex colors.

This is useful for taking a ring of edges and collapsing it,
removing the face loop it ran through.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_mesh_delete_collapse-before.png>   Selected edge ring. | <../../../../_images/modeling_meshes_editing_mesh_delete_collapse-after.png>   Edge ring collapsed. |
user: How do I use Example in Blender? Include parameters, examples, warnings and best practices.

assistant: Wave Distortion Effect samples.

|  |  |  |  |
| --- | --- | --- | --- |
| ../../_images/grease-pencil_visual-effects_wave-distortion_h10.png   Amplitude: 10 (horizontal). | ../../_images/grease-pencil_visual-effects_wave-distortion_h30.png   Amplitude: 30 (horizontal). | ../../_images/grease-pencil_visual-effects_wave-distortion_v10.png   Amplitude: 10 (vertical). | ../../_images/grease-pencil_visual-effects_wave-distortion_v30.png   Amplitude: 30 (vertical). |
user: How do I use GeometryNodeViewportTransform(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeViewportTransform(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.GeometryNodeViewportTransform(*GeometryNode*)
:   Retrieve the view direction and location of the 3D viewport

    *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: How do I use Position Offsetting in Blender? Include parameters, examples, warnings and best practices.

assistant: The constraint uses its owner’s position and rotation in [World Space](../../../glossary/index.xhtml#term-World-Space)
as offsets to the position and rotation on the Curve. If *Follow Curve*
is disabled, the offsets are added in the Curve’s [Local Space](../../../glossary/index.xhtml#term-Local-Space).
If it’s enabled, the offsets are added in the space of the current curve point,
with the global Y axis corresponding to the tangent direction.

In both cases, the Curve’s scale acts as a multiplier for the position offset.

|  |  |  |
| --- | --- | --- |
| ../../../_images/animation_constraints_relationship_follow-path_offset-no-constraint.png   Before adding the constraint, the cone is offset along the world Y axis. | ../../../_images/animation_constraints_relationship_follow-path_offset-no-follow-curve.png   After adding the constraint, the cone is offset along the Curve’s local Y axis. | ../../../_images/animation_constraints_relationship_follow-path_offset-follow-curve.png   When enabling Follow Curve, the cone is offset along the curve point’s tangent. |

To have the owner perfectly positioned and aligned on the Curve, ensure its
world position and rotation are both zero. This can be done by pressing `Alt`-`G`
and `Alt`-`R` respectively.
user: Explain Troubleshooting Linux – Intel in complete detail according to the official Blender documentation.

assistant: # Troubleshooting Linux – Intel

Blender uses OpenGL for the 3D Viewport and user interface. The graphics processing unit (GPU) and driver have a big
impact on Blender’s behavior and performance.

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.
user: Describe Select Invert from the Blender manual or Python API, including usage steps and snippets.

assistant: Inverts the selection state of each point in the point cloud:

- Points that were selected become deselected.
- Points that were not selected become selected.

This operator is useful for quickly selecting the opposite subset of points in your current selection.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`ImageStrip.retiming_keys`](bpy.types.ImageStrip.html#bpy.types.ImageStrip.retiming_keys "bpy.types.ImageStrip.retiming_keys") - [`MovieStrip.retiming_keys`](bpy.types.MovieStrip.html#bpy.types.MovieStrip.retiming_keys "bpy.types.MovieStrip.retiming_keys") | - [`SceneStrip.retiming_keys`](bpy.types.SceneStrip.html#bpy.types.SceneStrip.retiming_keys "bpy.types.SceneStrip.retiming_keys") - [`SoundStrip.retiming_keys`](bpy.types.SoundStrip.html#bpy.types.SoundStrip.retiming_keys "bpy.types.SoundStrip.retiming_keys") |
user: How do I use Snap Source Items in Blender? Include parameters, examples, warnings and best practices.

assistant: # Snap Source Items

CLOSEST:
:   Closest.

    Snap closest point onto target.

CENTER:
:   Center.

    Snap transformation center onto target.

MEDIAN:
:   Median.

    Snap median onto target.

ACTIVE:
:   Active.

    Snap active onto target.
user: Provide the full official documentation entry for Settings, preserving all code examples.

assistant: ### Light Probe

Resolution
:   The resolution used to store the light from the world.
    This is equivalent to the resolution for light probe spheres.

### Sun

EEVEE can separate the light from intense light sources
(e.g. a sun from an outdoor HDRI) and
replace them with a sun light. This increases the quality of the lighting as the internal light probes
alone cannot reproduce this type of lighting with enough precision.

Threshold
:   If non-zero, the maximum value for world contribution that will be recorded inside the world light probe.
    The excess contribution is converted to a sun light.
    This reduces the light bleeding caused by very bright light sources.
    A value of zero will disable this feature and all lighting will be stored inside the internal light probes.

Angle
:   Angular diameter of the extracted sun light as seen from the Earth.

Use Shadow
:   Enable shadow casting on the extracted sun light.
user: How do I use Sound Crossfade in Blender? Include parameters, examples, warnings and best practices.

assistant: # Sound Crossfade

The *Sound Crossfade* transition works by animating the *Volume*
of two overlapping Sound strips to evenly fade between them.
Because this simply animates a value it does not create a strip like other effects or transitions.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

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: Show practical ways to work with Viewport Stereo 3D in a Blender add-on or script – include code.

assistant: When you enable *Views* in the Render Layer panel, a new area is available in the 3D Viewport Sidebar region.
In this panel you can pick whether to see the stereo 3D in the viewport, or which camera to see.
It also allow you to see the *Cameras*, the *Plane* and the *Volume* of the stereo cameras.

[image reference removed]

Viewport stereo 3D settings.

Cameras
:   When working with the Stereo 3D Viewports setup, you can inspect what
    each individual generated camera is looking or the combined result of them.
    In the Multi-View mode you can see the combined result of the left and right cameras
    (when available) or the current selected camera.

Plane
:   The convergence plane represents the screen as it is perceived by the audience.
    Visualizing it in the 3D Viewport allows you to layout your scene
    based on your depth script outside the camera view.

Volume
:   The intersection of the stereo cameras frustums helps planning the show
    by avoiding elements being visible by only one camera.
    The volume is defined by the camera’s start and end clipping distances.
    The areas that are in the frustum of one camera only are known as *retinal rivalry areas*.
    They are tolerated in the negative space (the region from the convergence plane into the image)
    but are to be avoided at all costs in the positive space (the area from the convergence plane to the camera).

    [image reference removed]

    Viewport 3D: convergence plane and volume display.
user: How do I use Shader Editor in Blender? Include parameters, examples, warnings and best practices.

assistant: # Shader Editor

The Shader Editor is used to edit materials which are used for [rendering](../render/index.xhtml).
Materials used by Cycles and EEVEE are defined using a node tree.
Therefore, the main window of the Shader editor is a [node editor](../interface/controls/nodes/index.xhtml).

[image reference removed]

Shader Editor with the default material node tree.

A list of all [shader nodes](../render/shader_nodes/index.xhtml) is available in the rendering section.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Feather
:   Use or ignore feather points defined for splines see [Mask Feathers](../../../movie_clip/masking/scurve.xhtml#mask-feather) for more details.

Size Source
:   Where to get the mask size from for aspect/size information.

    Scene Size:
    :   Will give an image the size of the render resolution for the scene,
        scaling along when rendering with different resolutions.

    Fixed:
    :   Gives a fixed size in pixels.

    Fixed/Scene:
    :   Gives a size in pixels that still scales along when changing the render resolution percentage in the scene.

### Motion Blur

For animated masks, creating a motion blurred mask from the surrounding frames.

Samples
:   Number of motion blur samples.
    Higher values result in smoother and more accurate blur, but increase processing time.

Shutter
:   Duration of the motion blur in seconds, corresponding to the exposure time simulated for each frame.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Operation
:   The bitwise operation to apply:

    And:
    :   Returns a value where the bits of A and B are both set.

    Or:
    :   Returns a value where the bits of either A or B are set.

    Exclusive Or:
    :   Returns a value where only one of A or B has the bit set (XOR).

    Not:
    :   Inverts the bits of A. Equivalent to -A - 1 in decimal.

    Shift:
    :   Shifts the bits of A by the amount specified in *Shift*. Positive shifts are to the left; negative to the
        right.

    Rotate:
    :   Rotates the bits of A by the amount specified in *Shift*. Positive rotates left; negative rotates right.
user: Provide the full official documentation entry for Undo History, preserving all code examples.

assistant: [image reference removed]

The Undo History menu.

There is also an Undo History of the last actions taken, recorded by Blender.

The top of the list corresponds to the most recent actions.
A small icon of a dot next to one of the entries indicates the current status.
Rolling back actions using the *Undo History* feature will take you back to
the action you choose. Much like how you can alternate between going backward in
time with *Undo* and then forward with *Redo*,
you can hop around on the Undo timeline as much as you want as long as you do not make a new change.
Once you do make a new change, the Undo History is truncated at that point.
Selecting one of the entries in the list takes the current status to that position.
user: Explain Usage in complete detail according to the official Blender documentation.

assistant: First define the base of the object by dragging with `LMB`.
Next, release `LMB` and move the mouse to define the height of the object.
Finally, click `LMB` to confirm the shape of the object.

You can use the following hotkeys to temporarily change a setting
(for as long as the key is held):

|  |  |
| --- | --- |
| `Ctrl` | Toggles snapping. |
| `Alt` | Toggles the *Origin* setting. |
| `Shift` | Toggles the *Aspect* setting. |
user: Show practical ways to work with Strokes in a Blender add-on or script – include code.

assistant: # Strokes

Strokes are the final rendered lines. Yet you can tweak them, for example,
by removing the ones longer/shorter than some threshold,
chaining lines into a single stroke or breaking a stroke into several ones based on angles,
dashed pattern, etc.

[[image reference removed]](../../../../_images/render_freestyle_parameter-editor_line-style_strokes_tab.png)

Line Style: Strokes.

Caps
:   You can choose between three types of line caps:

    Butt:
    :   Flat cap, exactly at the point the line ends.

    Round:
    :   A half circle centered on the end point of the line.

    Square:
    :   A square centered on the end point of the line
        (hence, like the circle, the drawn end of the line is slightly extended compared to its computed value).

    [image reference removed]

    Line caps example.
user: Give a detailed overview of Duplicate Hair Curves: syntax, arguments, return values, common patterns.

assistant: # Duplicate Hair Curves

The *Duplicate Hair Curves* node creates additional copies of existing hair curves,
distributing them around the original guide curves within a specified radius.
This is useful for increasing hair density, creating secondary strands around guides,
or achieving fuller grooms without manually adding more guides.
user: What is Cursor and how is it used in Blender Python scripting?

assistant: The cursor can be disabled by toggling the checkbox in the *Cursor* header.

Color
:   Set the color of the brush ring. Depending on the current mode there will
    be options to set a single Color or a Color for Adding/Subtracting.
user: Explain Add-on Settings in complete detail according to the official Blender documentation.

assistant: Refresh Local
:   Scan extension & legacy add-ons for changes to modules & meta-data (similar to restarting).
    Any issues are reported as warnings.

Install from Disk
:   Install an extension from a `.zip` package.
    This is installed to a Local Repository and no updates will be available.

    This can also be used to install legacy Add-ons, for more information see:
    [Installing Legacy Add-ons](#prefs-extensions-install-legacy-addon).
user: Give a detailed overview of Import Text Node: syntax, arguments, return values, common patterns.

assistant: # Import Text Node

[image reference removed]

The *Import Text* node reads the contents of a plain text file and outputs it as a single string.
This can be useful in motion graphics or data-driven workflows where external text needs to be
processed or displayed.
user: Give a detailed overview of Animation: syntax, arguments, return values, common patterns.

assistant: There are two ways to add keyframes through Python.

The first is through key properties directly, which is like inserting a keyframe from the button as a user.
You can also manually create the curves and keyframe data, then set the path to the property.
Here are examples of both methods. Both insert a keyframe on the active object’s Z axis.

Simple example:

```
obj = bpy.context.object
obj.location[2] = 0.0
obj.keyframe_insert(data_path="location", frame=10.0, index=2)
obj.location[2] = 1.0
obj.keyframe_insert(data_path="location", frame=20.0, index=2)
```

Using low-level functions:

```
obj = bpy.context.object

# Create the action, with a slot for the object, a layer, and a keyframe strip:
action = bpy.data.actions.new(name="MyAction")
slot = action.slots.new(obj.id_type, obj.name)
strip = action.layers.new("MyLayer").strips.new(type='KEYFRAME')

# Create a channelbag to hold the F-Curves for the slot:
channelbag = strip.channelbag(slot, ensure=True)

# Create the F-Curve with two keyframes:
fcu_z = channelbag.fcurves.new(data_path="location", index=2)
fcu_z.keyframe_points.add(2)
fcu_z.keyframe_points[0].co = 10.0, 0.0
fcu_z.keyframe_points[1].co = 20.0, 1.0

# Assign the action and the slot to the object:
adt = obj.animation_data_create()
adt.action = action
adt.action_slot = slot
```
user: What is MESH_UL_vgroups(UIList) and how is it used in Blender Python scripting?

assistant: # MESH_UL_vgroups(UIList)

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

*class* bpy.types.MESH_UL_vgroups(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *icon*, *_active_data_*, *_active_propname*, *_index*)

    *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: Show practical ways to work with Render in a Blender add-on or script – include code.

assistant: SMAA Threshold
:   Threshold for the edge detection algorithm used to correct aliasing for the final render,
    Higher values may result in loss of detail due to excessive blurring.

SSAA Samples
:   Number of samples used for super-sampling anti-aliasing in the final render.
    Higher values produce smoother lines but increase render time.

Motion Blur Steps
:   Controls accuracy of [motion blur](../../../glossary/index.xhtml#term-Motion-Blur), more steps result in longer render time.
    Only used when [Motion Blur](../../cycles/render_settings/motion_blur.xhtml#bpy-types-rendersettings-use-motion-blur) is enabled.
    Set to 0 to disable motion blur for Grease Pencil objects.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: The *Closure* node does not have functional properties of its own, but its interface is configurable through the
*Node* tab in the Sidebar. Inputs and outputs can be added, removed, and renamed to define the closure’s signature.

Sync Sockets
:   Updates the current node to match the socket signature of the connected nodes.
    Use this after renaming, adding, or removing sockets.

Define Signature
:   Marks the current zone as the source of a closure signature that other nodes can reference. This ensures consistent
    input and output definitions across multiple closure instances.

### Input Items

List of input sockets
:   Displays one entry per socket defined in the closure. Double-click an entry to rename it.

Add Item
:   Add a new input socket to the closure.

Remove Item
:   Delete the selected input socket.

Type
:   Defines the data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value control appears and is used when the socket is unlinked.

Shape
:   Defines the data structure supported by the input socket, such as a *Single* value, *Field*, or *Grid*.
    The shape determines how the data is evaluated and passed through the node network.
    See [Socket Shape](../../../parts.xhtml#interface-controls-nodes-socket-shape) for more information.

### Output Items

Available when the closure’s output zone is selected.

List of output sockets
:   Displays one entry per socket defined in the closure output. Double-click to rename.

Add Item
:   Add a new output socket to the closure.

Remove Item
:   Delete the selected output socket.

Type
:   Defines the data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value control appears and is used when the socket is unlinked.

Shape
:   Defines the data structure supported by the input socket, such as a *Single* value, *Field*, or *Grid*.
    The shape determines how the data is evaluated and passed through the node network.
    See [Socket Shape](../../../parts.xhtml#interface-controls-nodes-socket-shape) for more information.
user: Show practical ways to work with Example in a Blender add-on or script – include code.

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

[The blend-file](https://archive.blender.org/wiki/2015/index.php/File:ManModifiersWeightVGroupEx.blend),
TEST_1 scene.