PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with ShaderNodeBsdfRefraction(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeBsdfRefraction(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.ShaderNodeBsdfRefraction(*ShaderNode*)
:   Glossy refraction with sharp or microfacet distribution, typically used for materials that transmit light

    distribution
    :   Light scattering distribution on rough surface

        Type:
        :   enum in [`'BECKMANN'`, `'GGX'`], default `'BECKMANN'`

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

assistant: SDF Grid
:   A scalar (float) grid representing the signed distance field of the input points.
    Each voxel stores the shortest signed distance to any point’s surface,
    with negative values inside the combined spheres and positive values outside.
user: Give a detailed overview of Extensions Command Line Arguments: syntax, arguments, return values, common patterns.

assistant: # Extensions Command Line Arguments

Command for managing Blender extensions.

options:
:   `-h, --help`
    :   show this help message and exit

subcommands:

> [Package Management](#package-management)
> :   list:
>     :   List all packages.
>
>     sync:
>     :   Synchronize with remote repositories.
>
>     update:
>     :   Upgrade any outdated packages.
>
>     install:
>     :   Install packages.
>
>     install-file:
>     :   Install package from file.
>
>     remove:
>     :   Remove packages.
>
> [Repository Management](#repository-management)
> :   repo-list:
>     :   List repositories.
>
>     repo-add:
>     :   Add repository.
>
>     repo-remove:
>     :   Remove repository.
>
> [Extension Creation](#extension-creation)
> :   build:
>     :   Build a package.
>
>     validate:
>     :   Validate a package.
>
>     server-generate:
>     :   Create a listing from all packages.
user: What is Modal Operators and how is it used in Blender Python scripting?

assistant: Modal operators exist as a concept in between [Tools](tool_system.xhtml)
and regular operators.
They require some sort of interactive input.

|  |  |
| --- | --- |
| `Esc`, `RMB` | Cancels a modal operator. |
| `Return`, `LMB` | Confirms the action of a modal operator. |

### Slider Operators

Slider operators are used to interactively adjust a percentage value
in the editor’s [Header](window_system/regions.xhtml#ui-region-header).

You can adjust the percentage by dragging the slider left or right.
This can be made coarser (snapping in 10% increments) by holding `Ctrl`
and more precise by holding `Shift`.
For some sliders, you can toggle “overshoot” with `E`, which lets
you go beyond the 0-100% range.
user: Give a detailed overview of Simple Mode: syntax, arguments, return values, common patterns.

assistant: Blender has two “modes” a simple and an advanced one. Simple mode only accepts simple numbers.

Decimals `Period`
:   Decimals can be entered by pressing `Period`.

Negate `Minus`
:   Negate the whole value by pressing `Minus`.

Inverse `Slash`
:   Hitting `Slash` during number entry switches the number being entered to
    its reciprocal, e.g. `2 /` results in 0.5 (1/2); `20 /` results in 0.05 (1/20).

Reset `Backspace`
:   Hitting `Backspace` after having deleted all leading chars
    will first reset the edited value to initial state, and on second press,
    the whole number editing will be canceled, going back to usual transform with mouse.

Next/Previous Component `Tab`, `Ctrl`-`Tab`
:   To enter numeric values for multiple axes, use `Tab` or `Ctrl`-`Tab`.
    E.g. To move an object, one unit on all three axes press: `G` `1`
    and `Tab` `1` and `Tab` `1`.

Non-number Inputs
:   You can also combine numeric input with
    [Axis Locking](axis_locking.xhtml)
    to limit movement to a particular axis or tool specific shortcuts.
user: Describe Object Origin from the Blender manual or Python API, including usage steps and snippets.

assistant: # Object Origin

Each object has an origin point. The location of this point determines where the object is located in 3D space.
When an object is selected, a small dot appears, denoting the origin point.
The location of the origin point is important when translating, rotating or scaling an object.
See [Pivot Points](../../editors/3dview/controls/pivot_point/index.html) for more.

The color of the origin changes based on the [selection](selecting.html)
state of the object.

Yellow:
:   Object is active.

Orange:
:   Object is selected, but not active.

White:
:   Object is not linked and not selected.

Turquoise:
:   Object is linked.

Light Turquoise:
:   Object is selected, linked, but not active.
user: Describe Selection from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| `LMB` | Select |
| `Ctrl`-`A` | Select All |
| `Shift`-`Ctrl`-`A` | Deselect All |
| `Ctrl`-`I` | Select Inverse |
| `Up` | Select More |
| `Down` | Select Less |
| Double `LMB` | Select Loop |
| Double `Alt`-`LMB` | Select Ring |
| `Ctrl` `L` | Select Linked |
user: Give a detailed overview of CompositorNodeSwitchView(CompositorNode): syntax, arguments, return values, common patterns.

assistant: # CompositorNodeSwitchView(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.CompositorNodeSwitchView(*CompositorNode*)
:   Combine the views (left and right) into a single stereo 3D output

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

assistant: [image reference removed]

The above example creates a curve Array with connections between curves.
This is created by duplicating the [Arc primitive](../curve/primitives/arc.xhtml)
curve with the [Duplicate Elements Node](../geometry/operations/duplicate_elements.xhtml).
Each curve is shifted in a top direction based on its index value.
All the curves are converted to the Point Cloud by the
[Curve to Points Node](../curve/operations/curve_to_points.xhtml).
Finally, the points are converted to curves by the Points to Curves node.

All the Points of the resulting Curves geometry have the same
attributes as points on the initial Arc primitive.
user: Explain Select Random in complete detail according to the official Blender documentation.

assistant: Adds random control points to the selection. The [Adjust Last Operation](../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last)
panel offers the following options:

Ratio
:   The ratio of control points that should end up selected, e.g. 0.5 to select half of all points
    (that are not [hidden](../../scene_layout/object/editing/show_hide.xhtml)).

    Note that the existing selection is ignored: if half of the control points are already selected,
    setting *Ratio* to 0.1 won’t deselect anything, nor will it select 10% of the unselected
    points. Instead, it always picks 10% of *all* visible points and adds them to the selection.

Random Seed
:   A number that influences which specific control points get picked.

Action
:   Select:
    :   Add random control points to the selection.

    Deselect:
    :   Remove random control points from the selection.
user: Explain Extrude Repeat in complete detail according to the official Blender documentation.

assistant: This tool behaves similar to the [Array Modifier](../../../modifiers/generate/array.xhtml),
by extruding the selection along the Z axis of the view.
If the selection is not [Manifold](../../../../glossary/index.xhtml#term-Manifold) it’s extruded the specified number of times.

Offset X, Y, Z
:   Distance between the instances.

Steps
:   Number of instances.

Scale Offset
:   Multiplication factor to increase or decrease the offset.
user: How do I use Show/Hide in Blender? Include parameters, examples, warnings and best practices.

assistant: Contains operators to adjust the visibility of points and strokes in the viewport.

### Show All Layers

Shows all Grease Pencil [layers](../../properties/layers.xhtml).

### Hide Active Layer

Hides the active Grease Pencil [layers](../../properties/layers.xhtml).

### Hide Inactive Layers

Hides the all Grease Pencil [layers](../../properties/layers.xhtml) except the active layer.
user: What is NodeSocketShader(NodeSocketStandard) and how is it used in Blender Python scripting?

assistant: # NodeSocketShader(NodeSocketStandard)

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

*class* bpy.types.NodeSocketShader(*NodeSocketStandard*)
:   Shader socket of a node

    links
    :   List of node links from or to this socket.

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

        (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: Explain Inherited Properties in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`StripModifier.name`](bpy.types.StripModifier.html#bpy.types.StripModifier.name "bpy.types.StripModifier.name") - [`StripModifier.type`](bpy.types.StripModifier.html#bpy.types.StripModifier.type "bpy.types.StripModifier.type") - [`StripModifier.mute`](bpy.types.StripModifier.html#bpy.types.StripModifier.mute "bpy.types.StripModifier.mute") - [`StripModifier.enable`](bpy.types.StripModifier.html#bpy.types.StripModifier.enable "bpy.types.StripModifier.enable") - [`StripModifier.show_expanded`](bpy.types.StripModifier.html#bpy.types.StripModifier.show_expanded "bpy.types.StripModifier.show_expanded") | - [`StripModifier.input_mask_type`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_type "bpy.types.StripModifier.input_mask_type") - [`StripModifier.mask_time`](bpy.types.StripModifier.html#bpy.types.StripModifier.mask_time "bpy.types.StripModifier.mask_time") - [`StripModifier.input_mask_strip`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_strip "bpy.types.StripModifier.input_mask_strip") - [`StripModifier.input_mask_id`](bpy.types.StripModifier.html#bpy.types.StripModifier.input_mask_id "bpy.types.StripModifier.input_mask_id") - [`StripModifier.is_active`](bpy.types.StripModifier.html#bpy.types.StripModifier.is_active "bpy.types.StripModifier.is_active") |
user: Explain Dt Mix Mode Items in complete detail according to the official Blender documentation.

assistant: # Dt Mix Mode Items

REPLACE:
:   Replace.

    Overwrite all elements’ data.

ABOVE_THRESHOLD:
:   Above Threshold.

    Only replace destination elements where data is above given threshold (exact behavior depends on data type).

BELOW_THRESHOLD:
:   Below Threshold.

    Only replace destination elements where data is below given threshold (exact behavior depends on data type).

MIX:
:   Mix.

    Mix source value into destination one, using given threshold as factor.

ADD:
:   Add.

    Add source value to destination one, using given threshold as factor.

SUB:
:   Subtract.

    Subtract source value to destination one, using given threshold as factor.

MUL:
:   Multiply.

    Multiply source value to destination one, using given threshold as factor.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Geometry
:   Standard geometry input.

Selection
:   Whether or not to change the value on each point or instance.
    True values mean the value will be changed, false values mean the value will remain the same.

ID
:   The value for each element. By default, this input uses
    the [index](../read/input_index.html), which is useful
    when stable IDs are desired when deleting a dynamic number of instances.
user: Show practical ways to work with NodeTreeInterfaceSocketVector(NodeTreeInterfaceSocket) in a Blender add-on or script – include code.

assistant: # NodeTreeInterfaceSocketVector(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.NodeTreeInterfaceSocketVector(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 3 items in [-inf, inf], default (0.0, 0.0, 0.0)

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

        Type:
        :   float in [-inf, inf], default 0.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: Show practical ways to work with Speed Control Strip in a Blender add-on or script – include code.

assistant: # Speed Control Strip

Speed Control time-warps the strip, making it play faster or slower than it normally would.
Playing faster means that some frames are skipped,
and the strip will run out of frames before the end frame.
When the strip runs out of frames to display, it will just keep repeating
the last one action that will appear to be frozen. To avoid this,
position the next strip under the original at a point where you want the motion to continue.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Image
:   Standard color input.

Threshold
:   Controls edge detection sensitivity across the whole image.

Contrast Limit
:   Controls contrast level to consider when detecting edges.

    The human eye does not perceive all edges equally. For instance,
    it tends to mask low contrast edges in the presence of much higher contrasts in the surrounding area.
    Therefore, applying anti-aliasing to unperceived edges will produce artifacts.
    This option quantifies the difference between low contrast and high contrast neighboring edges.

Corner Rounding
:   Detect corners to help preserve the original shape.
    Setting *Corner Rounding* to 0 means no corner detection and no corner rounding will take place.
    The higher the value the better corners will be preserved, i.e. resemble original image.
user: How do I use Separate Bones in Blender? Include parameters, examples, warnings and best practices.

assistant: # Separate Bones

You can, as with meshes, separate the selected bones in a new armature object
Armature ‣ Separate, `Ctrl`-`Alt`-`P` and of course,
in *Object Mode*, you can join all selected armatures in one
Object ‣ Join Objects, `Ctrl`-`J`.
user: What is EEVEE Limitations and how is it used in Blender Python scripting?

assistant: - [Depth of Field](../cameras.xhtml#bpy-types-cameradofsettings) and [Motion Blur](../eevee/render_settings/motion_blur.xhtml)
  are not rendered in passes other than *Combined*.
  They can be emulated in the Compositor using the [Defocus Node](../../compositing/types/filter/blur/defocus.xhtml)
  and the [Vector Blur Node](../../compositing/types/filter/blur/vector_blur.xhtml).
- Transparent materials that have their [Render Method](../eevee/material_settings.xhtml#bpy-types-material-surface-render-method)
  set to *Blended* are not rendered in passes other than *Combined* and *Transparent*.
  Use the *Dithered* method instead.
- The [Shader To RGB Node](../shader_nodes/color/shader_to_rgb.xhtml) only works correctly
  in the *Combined* pass as EEVEE excludes parts of the BSDF equation.
- There is a maximum of 16 *Color* and 16 *Value* AOVs (custom render passes).
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Combining this node with the [Sample Index Node](sample_index.xhtml) gives a setup that
can retrieve the closest attribute value from another geometry. This is the same behavior as the
*Transfer Attribute* node in versions of Blender before 3.4.
user: How do I use Combine Bundle Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Combine Bundle Node

[image reference removed]

The *Combine Bundle* node creates a new [Bundle](index.xhtml)
from multiple input values.
Each input becomes an element of the bundle, identified by its socket name.
Values can be accessed in other parts of the node tree using the
[Separate Bundle](separate_bundle.xhtml)
user: Give a detailed overview of File Paths: syntax, arguments, return values, common patterns.

assistant: # File Paths

The *File* section in *Preferences* allows you to configure auto-save preferences
and set default file paths for blend-files, rendered images, and more.

Locations for various external files can be set for the following options:

[image reference removed]

Preferences File Paths section.
user: Give a detailed overview of BlendDataBrushes(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # BlendDataBrushes(bpy_struct)

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

*class* bpy.types.BlendDataBrushes(*bpy_struct*)
:   Collection of brushes

    new(*name*, *\**, *mode='TEXTURE_PAINT'*)
    :   Add a new brush to the main database

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – New name for the data-block
            - **mode** (enum in [Object Mode Items](bpy_types_enum_items/object_mode_items.html#rna-enum-object-mode-items), (optional)) – Paint Mode for the new brush

        Returns:
        :   New brush data-block

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

    remove(*brush*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove a brush from the current blendfile

        Parameters:
        :   - **brush** ([`Brush`](bpy.types.Brush.html#bpy.types.Brush "bpy.types.Brush"), (never None)) – Brush to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this brush before deleting it
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this brush
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this brush

    tag(*value*)
    :   tag

        Parameters:
        :   **value** (*boolean*) – Value

    create_gpencil_data(*brush*)
    :   Add Grease Pencil brush settings

        Parameters:
        :   **brush** ([`Brush`](bpy.types.Brush.html#bpy.types.Brush "bpy.types.Brush"), (never None)) – Brush

    *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 Mesh Plane in a Blender add-on or script – include code.

assistant: # Mesh Plane

The *Mesh Plane* operator automates the process of creating a plane,
sizing it to match the aspect ratio of the selected image, and applying a material with the image as a texture.
The plane, material, and texture are named based on the image filename.

This tool supports importing single images, multiple images, or image sequences/movie clips:

- **Single Image**: Creates one plane with the image applied as a texture.
- **Multiple Images**: Generates multiple planes, either stacked or spaced apart.
- **Image Sequence/Movie Clip**: Creates a single plane with the animated sequence applied.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`GreasePencil.layers`](bpy.types.GreasePencil.html#bpy.types.GreasePencil.layers "bpy.types.GreasePencil.layers") - [`GreasePencilv3Layers.active`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.active "bpy.types.GreasePencilv3Layers.active") - [`GreasePencilv3Layers.move`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.move "bpy.types.GreasePencilv3Layers.move") - [`GreasePencilv3Layers.move_bottom`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.move_bottom "bpy.types.GreasePencilv3Layers.move_bottom") | - [`GreasePencilv3Layers.move_to_layer_group`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.move_to_layer_group "bpy.types.GreasePencilv3Layers.move_to_layer_group") - [`GreasePencilv3Layers.move_top`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.move_top "bpy.types.GreasePencilv3Layers.move_top") - [`GreasePencilv3Layers.new`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.new "bpy.types.GreasePencilv3Layers.new") - [`GreasePencilv3Layers.remove`](bpy.types.GreasePencilv3Layers.html#bpy.types.GreasePencilv3Layers.remove "bpy.types.GreasePencilv3Layers.remove") |
user: How do I use Auto-Save Preferences in Blender? Include parameters, examples, warnings and best practices.

assistant: By default, a new Blender installation is set to auto-save changes to preferences, so you don’t accidentally lose a
change you have made. To disable this behavior, perform these steps:

1. Open the Preferences dialog
2. Click on the small menu at the lower left (shown by 3 lines)
3. Uncheck the box next to “*Auto-Save Preferences*”
4. Click the “*Save Preferences*” button that will appear in the lower left of the dialog. **Don’t forget this step,
   as the change will not be saved otherwise.**

To enable auto-save once again, simply follow steps 1-3 above and check the box in step 3.
user: Show practical ways to work with IntProperty(Property) in a Blender add-on or script – include code.

assistant: # IntProperty(Property)

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

*class* bpy.types.IntProperty(*Property*)
:   RNA integer number property definition

    array_dimensions
    :   Length of each dimension of the array

        Type:
        :   int array of 3 items in [0, inf], [default](#bpy.types.IntProperty.default "bpy.types.IntProperty.default") (0, 0, 0), (readonly)

    array_length
    :   Maximum length of the array, 0 means unlimited

        Type:
        :   int in [0, inf], default 0, (readonly)

    default
    :   Default value for this number

        Type:
        :   int in [-inf, inf], default 0, (readonly)

    default_array
    :   Default value for this array

        Type:
        :   int array of 3 items in [-inf, inf], [default](#bpy.types.IntProperty.default "bpy.types.IntProperty.default") (0, 0, 0), (readonly)

    hard_max
    :   Maximum value used by buttons

        Type:
        :   int in [-inf, inf], default 0, (readonly)

    hard_min
    :   Minimum value used by buttons

        Type:
        :   int in [-inf, inf], default 0, (readonly)

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

    soft_max
    :   Maximum value used by buttons

        Type:
        :   int in [-inf, inf], default 0, (readonly)

    soft_min
    :   Minimum value used by buttons

        Type:
        :   int in [-inf, inf], default 0, (readonly)

    step
    :   Step size used by number buttons, for floats 1/100th of the step size

        Type:
        :   int in [0, inf], default 0, (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: Describe About UVs from the Blender manual or Python API, including usage steps and snippets.

assistant: Every point in the UV map corresponds to a vertex in the mesh.
The lines joining the UVs correspond to edges in the mesh.
Each face in the UV map corresponds to a mesh face.
Think of a UV map as projecting the surface of your 3D model onto a 2D image.

Each face of a mesh can have many UV textures. Each UV texture can have an individual image assigned to it.
When you unwrap a face to a UV texture in the UV Editor, each face of the mesh is automatically assigned
four UV coordinates: These coordinates define the way an image or a texture is mapped onto the face.
To distinguish from XYZ coordinates, the U and V axes are used to mark the coordinates of each point.
Hence the name, UV unwrapping. These coordinates can be used for rendering or for real-time viewport
display as well.

Every face in Blender can have a link to a different image.
The UV coordinates define how this image is mapped onto the face.
This image then can be rendered or displayed in real-time.
A 3D Viewport has to be in “Face Select” mode to be able to assign Images or
change UV coordinates of the active mesh object.
This allows a face to participate in many UV textures.
A face at the hairline of a character might participate in the facial UV texture,
*and* in the scalp/hair UV texture.

These are described more fully in the next sections.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Dimensions
:   The dimensions of the space to evaluate the noise in.

    1D:
    :   Evaluate the noise in 1D space at the input *W*.

    2D:
    :   Evaluate the noise in 2D space at the input *Vector*. The Z component is ignored.

    3D:
    :   Evaluate the noise in 3D space at the input *Vector*.

    4D:
    :   Evaluate the noise in 4D space at the input *Vector* and the input *W* as the fourth dimension.

Type
:   Type of Noise texture, with different ways to combine octaves.

    fBM:
    :   Fractal Brownian motion, produces a homogeneous and isotropic result.
        Values from octaves are added together.

    Multifractal:
    :   More uneven, varying by location similar to real terrain.
        Values from octaves are multiplied together.

    Hybrid Multifractal:
    :   Creates peaks and valleys with different roughness values, like real mountains rise out of flat plains.
        Combines octaves using both addition and multiplication.

    Ridged Multifractal:
    :   Creates sharp peaks. Calculates the absolute value of the noise,
        creating “canyons”, and then flips the surface upside down.

    Hetero Terrain:
    :   Similar to *Hybrid Multifractal* creates a heterogeneous terrain, but with the likeness of river channels.

Normalize fBM
:   If enabled, ensures that the output values stay in the range 0.0 to 1.0.
    If disabled, the range is at most -(*Detail* + 1) to *Detail* + 1 (smaller if *Roughness* < 1).
user: How do I use Light Probes in Blender? Include parameters, examples, warnings and best practices.

assistant: # Light Probes

Light probe objects are used by EEVEE as support objects.

There are three different types of light probes.
Each type of light probe records the lighting at a different resolution and frequency.
Probes are used together to recover incoming light information when using ray tracing is not possible
(either for performance or for technical limitations).

These types of objects are only useful for EEVEE (and by extension, the Material Preview mode).
user: What is Examples and how is it used in Blender Python scripting?

assistant: Three examples of how the size input may be used follow.

An [ID masked](../../mask/id_mask.xhtml)
alpha image can be used so that a background is blurred while foreground objects remain in focus.
To prevent strange edges the [Dilate Node](../dilate_erode.xhtml) should be used.

The Z pass can be visualized using a [Map Range](../../utilities/math/map_range.xhtml) node
and a [Color Ramp](../../color/color_ramp.xhtml) node
as described in [Render Layers](../../input/scene/render_layers.xhtml).
A *multiply* [Math](../../utilities/math/math.xhtml) node can be used following the color ramp
so that a blur value greater than one is used for objects outside the focal range.

[image reference removed]

Z pass used.

A manually created grayscale image can be used to define the sharp and blurry areas of a preexisting image.
Again, a Multiply Node can be used so that a blur value greater than one is used.

[image reference removed]

Image used.

|  |  |
| --- | --- |
| ../../../../_images/compositing_types_filter_bokeh-blur_example-1-render.jpg   Z pass used. | ../../../../_images/compositing_types_filter_bokeh-blur_example-2-render.jpg   Image used. |
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [[image reference removed]](../../../_images/modeling_modifiers_modify_weight-mix_panel.png)

The Vertex Weight Mix modifier panel.

Vertex Group A, B
:   - **A**: The vertex group to affect.
    - **B**: The second vertex group to mix into the affected one.
      Leave it empty if you only want to mix in a simple value.

    Invert Weights A/B
    :   Invert the influence of the vertex group.

Default Weight A, B
:   - **A**: The default weight to assign to all vertices not in the given vertex group.
    - **B**: The default weight to assign to all vertices not in the given second vertex group.

Vertex Set
:   Choose which vertices will be affected.

    All:
    :   Affects all vertices, disregarding the vertex groups content.

    Vertex Group A:
    :   Affects only vertices belonging to the affected vertex group.

    Vertex Group B:
    :   Affects only vertices belonging to the second vertex group.

    Vertex Group A or B:
    :   Affects only vertices belonging to at least one of the vertex groups.

    Vertex Group A and B:
    :   Affects only vertices belonging to both vertex groups.

Mix Mode
:   How the vertex group weights are affected by the other vertex group’s weights.

    Replace:
    :   Replaces affected weights with the second group’s weights.

    Add:
    :   Adds the values of *Group B* to *Group A*.

    Subtract:
    :   Subtracts the values of *Group B* from *Group A*.

    Multiply:
    :   Multiplies the values of *Group B* with *Group A*.

    Divide:
    :   Divides the values of *Group A* by *Group B*.

    Difference:
    :   Subtracts the smaller of the two values from the larger.

    Average:
    :   Adds the values together, then divides by 2.

    Minimum:
    :   Uses the smallest weight value of VGroup A’s or VGroup B’s weights.

    Maximum:
    :   Uses the largest weight value of VGroup A’s or VGroup B’s weights.

Normalize Weights
:   Scale the weights in the vertex group to keep the relative weight
    but the lowest and highest values follow the full 0 - 1 range.

### Influence

Those settings are the same for the three *Vertex Weight* modifiers,
see the [Vertex Weight Edit modifier](weight_edit.html#modeling-modifiers-weight-edit-influence-mask-options) page.
user: Describe GeometryNodeSDFGridMean(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeSDFGridMean(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.GeometryNodeSDFGridMean(*GeometryNode*)
:   Apply mean (box) filter smoothing to a signed distance field. Fast separable averaging filter for general smoothing of the distance field

    *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: What is Select Similar and how is it used in Blender Python scripting?

assistant: Selects control points that are similar in some way to a selected control point.
The [Adjust Last Operation](../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel provides options for this:

Type
:   Which property to compare for determining similarity.

    Type:
    :   This option does not apply for Surfaces because, unlike Curves, they only support one handle type.

    Radius:
    :   Selects control points that have a similar Radius value.
        See [Transform Panel](properties/transform_panel.html).

    Weight:
    :   Selects control points that have a similar Weight value.
        See [Transform Panel](properties/transform_panel.html).

    Direction:
    :   Selects control points that have a similar normal vector.

Compare
:   How to compare unselected control points to selected ones.

    Equal:
    :   Select control points whose property is equal to that of a selected point.

    Greater:
    :   Select control points whose property is greater than or equal to the smallest property
        among the selected points.

    Less:
    :   Select control points whose property is less than or equal to the greatest property
        among the selected points.

Threshold
:   Tolerance value for also including control points whose property is close to the property
    of a selected point. For example, if a selected control point has a Weight of 0.6 and
    the *Threshold* is set to 0.1, *Select Similar* will include all control points that have
    a Weight between 0.5 and 0.7.
user: Provide the full official documentation entry for Symmetry, preserving all code examples.

assistant: # Symmetry

Mirror
:   Mirror the brush strokes across the selected local axes.
    Note that if you want to alter the directions the axes point in,
    you must rotate the model in Edit Mode and not in Object Mode.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

*Generic Spring* constraint options.

Limits
:   X/Y/Z Axis
    :   Enables/disables limit translation on X, Y or Z axis respectively.

        Lower
        :   Lower limit of translation for X, Y or Z axis respectively.

        Upper
        :   Upper limit of translation for X, Y or Z axis respectively.

    X/Y/Z Angle
    :   Enables/disables limit rotation around the X, Y or Z axis respectively.

        Lower
        :   Lower limit of rotation for X, Y or Z axis respectively.

        Upper
        :   Upper limit of rotation for X, Y or Z axis respectively.

Springs
:   X/Y/Z Axis
    :   Enables/disables springs translation on X, Y or Z axis respectively.

        Stiffness
        :   Spring Stiffness of the translation on X, Y or Z axis respectively. Specifies how “bendy” the spring is.

        Damping
        :   Spring Damping of the translation on X, Y or Z axis respectively. Amount of damping the spring has.

    X/Y/Z Angle
    :   Enables/disables springs rotation around the X, Y or Z axis respectively.

        Stiffness
        :   Spring Stiffness of the rotation around the X, Y or Z axis respectively.
            Specifies how “bendy” the spring is.

        Damping
        :   Spring Damping of the rotation around the X, Y or Z axis respectively. Amount of damping the spring has.
user: Provide the full official documentation entry for ClothCollisionSettings(bpy_struct), preserving all code examples.

assistant: # ClothCollisionSettings(bpy_struct)

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

*class* bpy.types.ClothCollisionSettings(*bpy_struct*)
:   Cloth simulation settings for self collision and collision with other objects

    collection
    :   Limit colliders to this Collection

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

    collision_quality
    :   How many collision iterations should be done (higher is better quality but slower)

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

    damping
    :   Amount of velocity lost on collision

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

    distance_min
    :   Minimum distance between collision objects before collision response takes effect

        Type:
        :   float in [0.001, 1], default 0.015

    friction
    :   Friction force if a collision happened (higher = less movement)

        Type:
        :   float in [0, 80], default 5.0

    impulse_clamp
    :   Clamp collision impulses to avoid instability (0.0 to disable clamping)

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

    self_distance_min
    :   Minimum distance between cloth faces before collision response takes effect

        Type:
        :   float in [0.001, 0.1], default 0.015

    self_friction
    :   Friction with self contact

        Type:
        :   float in [0, 80], default 5.0

    self_impulse_clamp
    :   Clamp collision impulses to avoid instability (0.0 to disable clamping)

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

    use_collision
    :   Enable collisions with other objects

        Type:
        :   boolean, default True

    use_self_collision
    :   Enable self collisions

        Type:
        :   boolean, default False

    vertex_group_object_collisions
    :   Triangles with all vertices in this group are not used during object collisions

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

    vertex_group_self_collisions
    :   Triangles with all vertices in this group are not used during self collisions

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

    *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 Group Output in Blender? Include parameters, examples, warnings and best practices.

assistant: Receives the outputs of the node group. You can have multiple of these nodes in your tree to keep it clean,
outputting each result right where it’s produced (rather than dragging long links all across your graph).

The output slots can be edited in the *Group* tab of the *Sidebar*.