PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain Avoiding Alt-Mouse Conflict in complete detail according to the official Blender documentation.

assistant: Some window managers default to `Alt`-`LMB` and `Alt`-`RMB` for moving and resizing windows.

Blender uses these for various operations, notably:

- [Emulate 3 Button Mouse](../../editors/preferences/input.xhtml#bpy-types-preferencesinput-use-mouse-emulate-3-button).
- [Select Edge Loops](../../modeling/meshes/selecting/loops.xhtml#bpy-ops-mesh-loop-multi-select).
- [Changing multiple properties at once](../../interface/keymap/blender_default.xhtml#keymap-common-properties).

To access Blender’s full feature set, you can change the window manager settings to use the *Meta* key instead (also
called *Super* or *Windows* key):

Gnome
:   Enter the following in a command line (effective at next login):

    ```
    gsettings set org.gnome.desktop.wm.preferences mouse-button-modifier '<Super>'
    ```

KDE
:   System Settings ‣ Window Management ‣ Window Behavior ‣ Window Actions,
    Switch from ‘Alt’ to ‘Meta’ key.
user: What is Inherited Properties and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Paint.brush`](bpy.types.Paint.html#bpy.types.Paint.brush "bpy.types.Paint.brush") - [`Paint.brush_asset_reference`](bpy.types.Paint.html#bpy.types.Paint.brush_asset_reference "bpy.types.Paint.brush_asset_reference") - [`Paint.eraser_brush`](bpy.types.Paint.html#bpy.types.Paint.eraser_brush "bpy.types.Paint.eraser_brush") - [`Paint.eraser_brush_asset_reference`](bpy.types.Paint.html#bpy.types.Paint.eraser_brush_asset_reference "bpy.types.Paint.eraser_brush_asset_reference") - [`Paint.palette`](bpy.types.Paint.html#bpy.types.Paint.palette "bpy.types.Paint.palette") - [`Paint.show_brush`](bpy.types.Paint.html#bpy.types.Paint.show_brush "bpy.types.Paint.show_brush") - [`Paint.show_brush_on_surface`](bpy.types.Paint.html#bpy.types.Paint.show_brush_on_surface "bpy.types.Paint.show_brush_on_surface") - [`Paint.show_low_resolution`](bpy.types.Paint.html#bpy.types.Paint.show_low_resolution "bpy.types.Paint.show_low_resolution") - [`Paint.use_sculpt_delay_updates`](bpy.types.Paint.html#bpy.types.Paint.use_sculpt_delay_updates "bpy.types.Paint.use_sculpt_delay_updates") - [`Paint.use_symmetry_x`](bpy.types.Paint.html#bpy.types.Paint.use_symmetry_x "bpy.types.Paint.use_symmetry_x") - [`Paint.use_symmetry_y`](bpy.types.Paint.html#bpy.types.Paint.use_symmetry_y "bpy.types.Paint.use_symmetry_y") | - [`Paint.use_symmetry_z`](bpy.types.Paint.html#bpy.types.Paint.use_symmetry_z "bpy.types.Paint.use_symmetry_z") - [`Paint.use_symmetry_feather`](bpy.types.Paint.html#bpy.types.Paint.use_symmetry_feather "bpy.types.Paint.use_symmetry_feather") - [`Paint.cavity_curve`](bpy.types.Paint.html#bpy.types.Paint.cavity_curve "bpy.types.Paint.cavity_curve") - [`Paint.use_cavity`](bpy.types.Paint.html#bpy.types.Paint.use_cavity "bpy.types.Paint.use_cavity") - [`Paint.tile_offset`](bpy.types.Paint.html#bpy.types.Paint.tile_offset "bpy.types.Paint.tile_offset") - [`Paint.tile_x`](bpy.types.Paint.html#bpy.types.Paint.tile_x "bpy.types.Paint.tile_x") - [`Paint.tile_y`](bpy.types.Paint.html#bpy.types.Paint.tile_y "bpy.types.Paint.tile_y") - [`Paint.tile_z`](bpy.types.Paint.html#bpy.types.Paint.tile_z "bpy.types.Paint.tile_z") - [`Paint.show_strength_curve`](bpy.types.Paint.html#bpy.types.Paint.show_strength_curve "bpy.types.Paint.show_strength_curve") - [`Paint.show_size_curve`](bpy.types.Paint.html#bpy.types.Paint.show_size_curve "bpy.types.Paint.show_size_curve") - [`Paint.show_jitter_curve`](bpy.types.Paint.html#bpy.types.Paint.show_jitter_curve "bpy.types.Paint.show_jitter_curve") - [`Paint.unified_paint_settings`](bpy.types.Paint.html#bpy.types.Paint.unified_paint_settings "bpy.types.Paint.unified_paint_settings") |
user: Give a detailed overview of CompositorNodeRGBToBW(CompositorNode): syntax, arguments, return values, common patterns.

assistant: # CompositorNodeRGBToBW(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.CompositorNodeRGBToBW(*CompositorNode*)
:   Convert RGB input into grayscale using luminance

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

assistant: # CompositorNodeColorMatte(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.CompositorNodeColorMatte(*CompositorNode*)
:   Create matte using a given color, for green or blue screen footage

    *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 Introduction, preserving all code examples.

assistant: # Introduction

[image reference removed]

The Texture Type list in the Texture panel of the Texture buttons.

Procedural textures are textures that are defined mathematically.
They are generally relatively simple to use,
because they do not need to be mapped in a special way.
This does not mean that procedural textures cannot become very complex.

These types of textures are ‘real’ 3D. By that we mean that they fit together perfectly at
the edges and continue to look like what they are meant to look like even when they are cut;
as if a block of wood had really been cut in two.
Procedural textures are not filtered or anti-aliased. This is hardly ever a problem:
the user can easily keep the specified frequencies within acceptable limits.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Type
:   *Bands* or *Rings* shaped waves.

Bands/Rings Direction
:   The axis the bands or rings propagate from i.e. which axis they are perpendicular to.
    When using *Bands* a *Diagonal* axis is an option and when using *Rings* the rings
    can propagate outwards from a single point by using *Spherical* direction.

Wave Profile
:   Controls the look of the wave type.

    Saw:
    :   Uses a sawtooth profile.

    Sine:
    :   Uses the standard sine profile.
user: Give a detailed overview of CompositorNodeCrop(CompositorNode): syntax, arguments, return values, common patterns.

assistant: # CompositorNodeCrop(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.CompositorNodeCrop(*CompositorNode*)
:   Crops image to a smaller region, either making the cropped area transparent or resizing the image

    *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: Explain Bone Structure in complete detail according to the official Blender documentation.

assistant: # Bone Structure

[image reference removed]

The elements of a bone.

They have three elements:

1. The “start joint” named *root* or *head*.
2. The “body” itself.
3. And the “end joint” named *tip* or *tail*.

With the default armature in Edit Mode,
you can select the root and the tip, and move them as you do with mesh vertices.

Both root and tip (the “joints”) define the bone by their respective position.

They also have a radius property, only useful for the envelope deformation method (see below).
user: Show practical ways to work with Tool Settings in a Blender add-on or script – include code.

assistant: You can configure the brush main settings exposed on the Tool Settings for convenience.
For the draw brushes configuration and settings see:
[Draw Brush](../brushes/draw.xhtml).

Subdivisions
:   The number of stroke points between each stroke edge.

Thickness Profile
:   Use a [curve widget](../../../../interface/controls/templates/curve.xhtml) to define the stroke thickness
    from the start (left) to end (right) of the stroke.

    Use Curve
    :   When enabled, the stroke use a curve profile to control the thickness along the curve.

Different thickness profile samples.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_curve_thickness-profile-01.png | ../../../../_images/grease-pencil_modes_draw_tools_curve_thickness-profile-02.png | ../../../../_images/grease-pencil_modes_draw_tools_curve_thickness-profile-03.png |

### Brush Asset

Picks the brush asset used by the tool.

See [Brush Asset](../tool_settings/brushes.xhtml) for more information.

See [Draw Brushes](../brushes/draw.xhtml) for a detailed list of all draw brushes and their options.

### Brush Settings

Parameters to control to look of the stroke.

See [Draw Brushes](../brushes/draw.xhtml) for details.

### Color

Settings to determine the color of strokes.

See [Color](../tool_settings/color.xhtml)
user: Describe TextureNodeHueSaturation(TextureNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # TextureNodeHueSaturation(TextureNode)

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The navigation gizmo can be found in the top right of the editor.

Navigation Gizmo (left) and Navigation Gizmo in camera view (right).

|  |  |
| --- | --- |
| ../../../_images/editors_3dview_navigate_introduction_gizmo.png | ../../../_images/editors_3dview_navigate_introduction_gizmo_camera_view.png |

The Orbit gizmo at the top shows the current orientation of the view.
Dragging it with `LMB` will [orbit](navigation.xhtml#bpy-ops-view3d-view-orbit) the view.
Clicking any of the axis labels will [align](viewpoint.xhtml) the view to that axis.
Clicking the same axis again switches to the opposite side of that same axis.

The four buttons below the orbit gizmo do the following:

- [Zoom the 3D Viewport](navigation.xhtml#bpy-ops-view3d-zoom)
- [Pan the 3D Viewport](navigation.xhtml#bpy-ops-view3d-view-pan)
- [Toggle the Camera View](camera_view.xhtml)
- [Toggle the Projection](projections.xhtml) /
  [Toggle Lock Camera to View](../sidebar.xhtml#bpy-types-spaceview3d-lock-camera) (in camera view)
user: Give a detailed overview of NodeEvaluateClosureInputItem(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # NodeEvaluateClosureInputItem(bpy_struct)

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

*class* bpy.types.NodeEvaluateClosureInputItem(*bpy_struct*)
:   color
    :   Color of the corresponding socket type in the node editor

        Type:
        :   float array of 4 items in [0, inf], default (0.0, 0.0, 0.0, 0.0), (readonly)

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

    socket_type
    :   Type:
        :   enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items), default `'FLOAT'`

    structure_type
    :   What kind of higher order types are expected to flow through this socket

        Type:
        :   enum in [Node Socket Structure Type Items](bpy_types_enum_items/node_socket_structure_type_items.html#rna-enum-node-socket-structure-type-items), default `'AUTO'`

    *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 Hide Gesture Tools, preserving all code examples.

assistant: # Hide Gesture Tools

Hide gesture tools hide all selected vertices within the selection area and any of their connected
edges and faces.
Holding `Ctrl` while performing the selection reveals the vertices, edges, and faces.

Pressing `LMB` with any of these tools without also dragging reveals all elements of a mesh.

All hide gesture tools can be activated in the Toolbar and are comprised of the following:
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: Shadow Effect samples.

|  |  |  |
| --- | --- | --- |
| ../../_images/grease-pencil_visual-effects_shadow_simple.png   Simple Shadow. | ../../_images/grease-pencil_visual-effects_shadow_blur.png   Blurred Shadow. | ../../_images/grease-pencil_visual-effects_shadow_stretch.png   Stretched shadow with an empty as center of rotation. |
user: What is GeometryNodeStringJoin(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeStringJoin(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.GeometryNodeStringJoin(*GeometryNode*)
:   Combine any number of input strings

    *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 NodeIndexSwitchItems(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeIndexSwitchItems(bpy_struct)

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

*class* bpy.types.NodeIndexSwitchItems(*bpy_struct*)
:   Collection of index_switch items

    new()
    :   Add an item at the end

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

        Parameters:
        :   **item** ([`IndexSwitchItem`](bpy.types.IndexSwitchItem.html#bpy.types.IndexSwitchItem "bpy.types.IndexSwitchItem"), (never None)) – Item, The item to remove

    clear()
    :   Remove all items

    move(*from_index*, *to_index*)
    :   Move an item to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the item to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the item

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # General

*Sculpt Mode* is similar to *Edit Mode* in that it is used to alter the shape of a model,
but Sculpt Mode uses a very different workflow:
instead of dealing with individual elements (vertices, edges, and faces),
an area of the model is primarily changed using brushes.

[image reference removed]

Sculpting Mode Example.

Sculpt Mode is accessed from the mode menu of the [3D Viewport header](../../../editors/3dview/modes.xhtml)
or with the pie menu via `Ctrl`-`Tab`.
Once inside Sculpt Mode, the Toolbar and Tool Settings of the 3D Viewport will change to
Sculpt Mode specific panels. The cursor will change to a circle, to indicate the size of the brush.

The following pages will briefly explain the fundamental features and concepts of *Sculpt Mode*,
including various links to other pages for more details.
user: What is Main Region and how is it used in Blender Python scripting?

assistant: At least one region is always visible.
It is called the Main region and is the most prominent part of the editor.

Each editor has a specific purpose, so the main region and
the availability of additional regions are different between editors.
See specific documentation about each editor in the [Editors](../../editors/index.html) chapter.
user: Explain CameraDOFSettings(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # CameraDOFSettings(bpy_struct)

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

*class* bpy.types.CameraDOFSettings(*bpy_struct*)
:   Depth of Field settings

    aperture_blades
    :   Number of blades in aperture for polygonal bokeh (at least 3)

        Type:
        :   int in [0, 16], default 0

    aperture_fstop
    :   F-Stop ratio (lower numbers give more defocus, higher numbers give a sharper image)

        Type:
        :   float in [0, inf], default 2.8

    aperture_ratio
    :   Distortion to simulate anamorphic lens bokeh

        Type:
        :   float in [0.01, inf], default 1.0

    aperture_rotation
    :   Rotation of blades in aperture

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

    focus_distance
    :   Distance to the focus point for depth of field

        Type:
        :   float in [0, inf], default 10.0

    focus_object
    :   Use this object to define the depth of field focal point

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

    focus_subtarget
    :   Use this armature bone to define the depth of field focal point

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

    use_dof
    :   Use Depth of Field

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Creating Meta-rigs: syntax, arguments, return values, common patterns.

assistant: # Creating Meta-rigs

1. Add a single bone from the Add ‣ Armature menu.
2. Go in armature Edit Mode and build the meta rig by samples or Rigify types.
3. Define the [Rigify bone collection UI](#bpy-types-bonecollection-rigify-ui-row),
   [color sets](#bpy-types-armature-rigify-colors), and selection sets.
4. In the armature properties click on the *Generate* button to generate the rig.
user: Describe Admonitions from the Blender manual or Python API, including usage steps and snippets.

assistant: Admonitions are special blocks used to highlight important notes, warnings,
or additional information in the documentation.

Common admonition types include:

- `note`
- `tip`
- `important`
- `warning`
- `caution`
- `seealso`

Admonitions are created using the following markup:

```
.. note::

   This is a note for general information.
```

Other types can be rendered by replacing `note` with the desired type from the list above.
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: X, Y, Z
:   The integer indices of the current voxel in the grid along each axis.

    These values identify which voxel is being sampled by the field at this
    evaluation point. They can be offset (for example, add or subtract 1 on X)
    and then passed to [Sample Grid Index](../sample/sample_grid_index.xhtml)
    to read values from neighboring voxels.

### Tile

Is Tile
:   Whether the current evaluation is happening on a *tile* rather than on a
    single voxel.

    Some operations evaluate fields on tiles that cover multiple voxels at
    once for performance reasons. In those cases the coordinates given by
    *X*, *Y*, and *Z* alone are not enough to describe the full covered region.

    If this is false, the extent is always 1.

Extent X, Extent Y, Extent Z
:   The number of voxels along each axis of the tile.

    For a normal voxel, the extent on each axis is `1`.
    For a tile that covers multiple voxels, the extents describe how many
    voxels are grouped together in X, Y, and Z.

    These outputs can be used to detect and handle cases where an evaluation
    represents an aggregated region (a tile) instead of an individual voxel,
    so that the result is not misinterpreted as referring to just one voxel.
user: How do I use Duplicate in Blender? Include parameters, examples, warnings and best practices.

assistant: Creates a copy of the selected points and reposition the duplicated points.

Duplicated points inherit all attributes from the original points.
- Can be used for manually scattering point clusters or duplicating specific regions for further modification.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Mode
:   Points:
    :   The position and radius of the arc are determined by three points.
        The center of the arc, radius and normal are also given as outputs.

    Radius:
    :   The arc is determined by the radius, start angle and sweep angle.
user: What is Calculate Mass and how is it used in Blender Python scripting?

assistant: Calculate mass values for rigid body objects based on their volume and density.
The volume is calculated automatically, the density needs to be given based on the object you want to simulate.

Material Preset
:   A list of preset density values for real-world materials,
    if a material is not given you can research the density and use the *Custom* preset to input the density manually.

Density
:   When the *Custom* *Material Preset* is selected, this is the input density, in kg/m3, to use.
user: Show practical ways to work with Scatter on Surface Modifier in a Blender add-on or script – include code.

assistant: # Scatter on Surface Modifier

The *Scatter on Surface* modifier distributes points or instances across the surface of a mesh.
It provides flexible control over how elements are placed using density, randomization,
and Poisson disk sampling.
This modifier is useful for procedural scattering of objects such as grass, rocks, or debris
on terrain or any other surface.
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

The above example generates a pyramid with a configurable number of levels.
Each iteration creates a cube, brings it into position, and
[joins](../geometry/join_geometry.html) it with the result of
the previous iteration.
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Bend* tool can be used in any case where you might want to bend a shape in two
with a gradual transition between both sides.

This may take a little getting used to, the basics are listed below controls are noted here:

- The initial position of the cursors define the axis to bend on.
- The distance of the mouse cursor to the 3D cursor controls how sharp the bend will be.
- The relative angle of the mouse cursor to the initial axis defines the bend angle.

If this seems overly complicated, it’s probably best to try the tool
where it becomes quickly apparent how the tool reacts to your input.

Bend Angle
:   The amount of rotation.

Radius
:   The sharpness of the bend.

Clamp
:   Normally the arc turns through a clamped rotation angle with the selected elements extended along
    a tangent line beyond that (see above left).
    When the clamp is deactivated, the arc continues around aligning the selected elements into a circle (right).

    When off `Alt` all selected elements follow a circle,
    even when outside the segment between the 3D cursor and the mouse.

[image reference removed]

Bend Transform example.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Curve
:   Standard geometry input with a curve component.

Radius
:   The radius of the circle portion generated at each fillet.

Count
:   Only in *Poly* mode, the number of control points to add for each fillet.

Limit Radius
:   Whether to limit the maximum value of the radius in order to avoid overlapping fillets.

Mode
:   How to choose number of vertices on fillet

    Bézier:
    :   Only two control points will be generated for every filleted control point. The shape generated
        by the aligned handles on the generated control points on either side of the fillet is used to
        create the circle portion shape, meaning that the number of segments in the fillet shape depends on
        the [spline’s resolution value](../read/spline_resolution.html).

    Poly:
    :   The number of control points generated for each field
        input is controlled directly with an integer field input.
        This mode works better for poly and NURBS splines.
user: Describe Distance from Object from the Blender manual or Python API, including usage steps and snippets.

assistant: # Distance from Object

The *Distance from Object* modifier alters the base property with a new one
from a given range using the distance to the active *camera* or to a given *object* as the parameter.

Target
:   The object to measure distance from.

Range Min, Max
:   The limits of the mapping from “distance to camera” to “property in mapping”.
    If the current point of the stroke is at *Range Min* or less from the active camera or the object,
    it will take the start value. And conversely,
    if it is at *Max* or more from the camera/object, it will take the end value.
    These values are in the current scene’s units, not in pixels!

Fill Range by Selection
:   Set the min/max range values from the distances between the current selected mesh vertices and
    the camera or the target.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Vector
:   Texture coordinate to sample texture at;
    defaults to Generated texture coordinates if the socket is left unconnected.

Scale
:   Scale of the texture.

Distortion
:   Amount of distortion.
user: Describe Curve Root from the Blender manual or Python API, including usage steps and snippets.

assistant: # Curve Root

The *Curve Root* node outputs information related to the root point of each curve.
It is commonly used in hair grooming and procedural setups to anchor deformations,
apply transformations relative to the curve base, or isolate operations affecting
only the roots.
user: Provide the full official documentation entry for Selecting Bones, preserving all code examples.

assistant: # Selecting Bones

Selection in *Pose Mode* is very similar to the one in [Edit Mode](../bones/selecting.html),
with a few deviations:
You can only select *whole bones* in *Pose Mode*, not roots/tips…
user: Describe Tool Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: A horizontal strip at the top or bottom of the editor (similar to the header)
containing settings for the currently selected tool. Just like the header,
it can be hidden and moved through its context menu.
user: What is Usage and how is it used in Blender Python scripting?

assistant: 1. Choose File ‣ New ‣ Video Editing to open the template.
2. Use the File Browser to locate your media files.
3. Drag and drop media (movies, images, or sounds) into the Sequencer area.
4. Arrange and edit the strips as needed.
5. Use Render ‣ Render Animation to export your final video.

This template offers an efficient starting point for editing projects, combining layout, settings,
and workflow elements tailored for video production.
user: What is Clean Up and how is it used in Blender Python scripting?

assistant: ### Decimate Curve

The *Decimate Curve* operator reduces the number of control points
while trying to maintain the curves original shape.
This operator works similar to its [mesh counterpart](../../meshes/editing/mesh/cleanup.xhtml#bpy-ops-mesh-decimate).

Ratio
:   The percentage of control points to remove.
user: Give a detailed overview of Common Brushes: syntax, arguments, return values, common patterns.

assistant: There are many brushes to choose from but these are the most common brushes to be used during sculpting.
More information on sculpting brushes in the [Toolbar](../toolbar.xhtml).

[image reference removed]

[Clay Strips](../brushes/clay_strips.xhtml)
:   Block out broad shapes and build up volumes before refining them further.

[Grab](../brushes/grab.xhtml)
:   Move geometry across the screen for general shaping.

[Smooth](../brushes/smooth.xhtml)
:   Smooth and shrink surfaces to remove noise or flatten shapes.

[Draw](../brushes/draw.xhtml)
:   Generic adding and subtracting on surfaces.
    This brush is often customized with different stroke methods and textures for various effects.

[Plane](../brushes/plane.xhtml)
:   Scrape and fill surfaces either for hard surface sculpting or more aggressive smoothing.

[Inflate](../brushes/inflate.xhtml)
:   Inflate or shrink volumes or surfaces.
    Especially useful for controlling the thickness of cylindrical shapes.

[Draw Sharp](../brushes/draw_sharp.xhtml)
:   Same as *Draw* but with a much sharper falloff. Useful for adding creases, cracks and other sharp edges.

[Crease](../brushes/crease.xhtml)
:   A mix of the *Draw* and *Pinch* brushes.
    Useful for creating detailed creases or sharpening existing creases for additional polish.

[Snake Hook](../brushes/snake_hook.xhtml).
:   Similar to *Grab* but this brush will dynamically let go and pick up geometry during the stroke.
    The dragged geometry is also following the angle of the stroke, making it very useful for
    pulling geometry out.
    Ideally used together with [Dyntopo](adaptive.xhtml#dyntopo-introduction).
user: What is PropertyGroup Example and how is it used in Blender Python scripting?

assistant: PropertyGroups can be used for collecting custom settings into one value
to avoid many individual settings mixed in together.

```
import bpy

class MaterialSettings(bpy.types.PropertyGroup):
    my_int: bpy.props.IntProperty()
    my_float: bpy.props.FloatProperty()
    my_string: bpy.props.StringProperty()

bpy.utils.register_class(MaterialSettings)

bpy.types.Material.my_settings = bpy.props.PointerProperty(type=MaterialSettings)

# Test the new settings work.
material = bpy.data.materials[0]

material.my_settings.my_int = 5
material.my_settings.my_float = 3.0
material.my_settings.my_string = "Foo"
```
user: How do I use Grid Info Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Grid Info Node

[image reference removed]

The *Grid Info* node retrieves structural and metadata information about a voxel grid.
It provides details such as the grid’s spatial transform and background value,
which describe how the grid is positioned in space and what value is stored in
inactive (empty) voxels.

This node is useful for inspecting or reusing grid parameters in other grid
operations, such as aligning transforms, matching resolutions, or reconstructing
fields with consistent background values.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Image
:   Image input, to be linked to the “Combined” render pass.

Speed
:   Input for the “Vector” render pass.
    See [Cycles render passes](../../../../render/layers/passes.xhtml).

Z
:   Z depth, to be linked to the “Depth” render pass.

Samples
:   Quality factor.

Shutter
:   Duration of the motion blur in seconds, corresponding to the exposure time simulated for each frame.
user: How do I use Make Vertex Parent in Blender? Include parameters, examples, warnings and best practices.

assistant: Creates a [parent-child relationship](../../../scene_layout/object/editing/parent.html#object-parenting) that makes a particular object
follow the selected control point(s).

While in Edit Mode, select another object by either clicking it with `Ctrl`-`LMB` in the
3D Viewport or by selecting it the [Outliner](../../../editors/outliner/introduction.html).
Then, select one or three control points of the surface and press `Ctrl`-`P`.
Parenting an object to three control points will make it follow their averaged position.
user: Explain Roll Hair Curves in complete detail according to the official Blender documentation.

assistant: # Roll Hair Curves

The *Roll Hair Curves* node coils or curls the tips of hair curves, rolling them inward or outward
based on configurable geometric parameters.
This node can be used to create spiral or curled hairstyles, simulate rolled fur, or stylize hair motion.
user: Provide the full official documentation entry for Area(bpy_struct), preserving all code examples.

assistant: # Area(bpy_struct)

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

*class* bpy.types.Area(*bpy_struct*)
:   Area in a subdivided screen, containing an editor

    height
    :   Area height

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

    regions
    :   Regions this area is subdivided in

        Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`Region`](bpy.types.Region.html#bpy.types.Region "bpy.types.Region"), (readonly)

    show_menus
    :   Show menus in the header

        Type:
        :   boolean, default False

    spaces
    :   Spaces contained in this area, the first being the active space (NOTE: Useful for example to restore a previously used 3D view space in a certain area to get the old view orientation)

        Type:
        :   [`AreaSpaces`](bpy.types.AreaSpaces.html#bpy.types.AreaSpaces "bpy.types.AreaSpaces") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`Space`](bpy.types.Space.html#bpy.types.Space "bpy.types.Space"), (readonly)

    type
    :   Current editor type for this area

        Type:
        :   enum in [Space Type Items](bpy_types_enum_items/space_type_items.html#rna-enum-space-type-items), default `'VIEW_3D'`

    ui_type
    :   Current editor type for this area

        Type:
        :   enum in []

    width
    :   Area width

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

    x
    :   The window relative vertical location of the area

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

    y
    :   The window relative horizontal location of the area

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

    tag_redraw()
    :   tag_redraw

    header_text_set(*text*)
    :   Set the header status text

        Parameters:
        :   **text** (*string*) – Text, New string for the header, None clears the text

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.Area.type "bpy.types.Area.type")
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Location
:   Location of the object in world space.

Color
:   Object color, same as *Color* in the Properties ‣ Object Properties ‣ Viewport Display.

Alpha
:   The [Alpha Channel](../../../glossary/index.xhtml#term-Alpha-Channel) component of the object’s viewport display color (see the *Color* output for
    more details).

Object Index
:   Object pass index, same as *Pass Index*
    in the Properties ‣ Object Properties ‣ Relations.

Material Index
:   Material pass index, same as *Pass Index*
    in the Properties ‣ Material ‣ Settings.

Random
:   Random number unique to a single object instance. Output is a Float between 0.0 and 1.0
user: Provide the full official documentation entry for Tool Settings, preserving all code examples.

assistant: If your tool requires any input from the user apart from the geometry to transform,
you can [add sockets](../../interface/controls/nodes/groups.xhtml#bpy-ops-node-interface-item-new) to the *Group Input* node.
These will be exposed in the [Adjust Last Operation](../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel when running the tool.
user: Show practical ways to work with limbs.paw in a Blender add-on or script – include code.

assistant: Will create a fully featured bendy and stretchy paw depending on the user-defined options.

Requirement: A chain of four or five connected bones (thigh, shin, paw, *optional* digit, toe).

[image reference removed]

Front/Rear paw required bones.

Rotation Axis (Automatic, X, Z)
:   Defines the bend axis for the IK chain. FK chains will have a totally free degree of rotation on all axes.

Limb Segments (integer)
:   Defines the number of additional tweak controls each limb bone will have on the final rig.

B-Bone Segments (integer)
:   Defines the number of b-bone segments each tweak control will be split into.

Custom IK Pivot
:   Generates an extra control for the end of the IK limb that allows rotating it around an arbitrarily placed pivot.

Assign FK Layers
:   If enabled, allows placing the FK chain in different bone collections from the IK bones.

Assign Tweak Layers
:   If enabled, allows placing the Tweak controls in different bone collections from the IK bones.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

The first step is to unwrap your mesh. Generally, it is recommended to start unwrapping
when only minor adjustments to the geometry of your model are required.
If you do add faces or subdivide existing faces when a model is already unwrapped,
Blender will add those new faces for you,
but you may need to do additional mapping or editing. In this fashion,
you can use the UV texture image to guide additional geometry changes.
user: Provide the full official documentation entry for Blend-File Preview, preserving all code examples.

assistant: Blender saves by default a small preview of current scene in the blend-file.
This will show in the *Thumbnail* view of the [File Browser](../../editors/file_browser.xhtml).

During its installation, Blender also adds a small tool to your OS,
that will allow your system file browser to show those previews as file thumbnails as well.

### macOS

The Blender Thumbnail extension can be disabled in the System Settings under “Login Items & Extensions”,
within the Quick Look category.
user: Give a detailed overview of Quick Start: syntax, arguments, return values, common patterns.

assistant: Open the terminal application,
and run the executable within the app bundle, with commands like this:

```
cd /Applications/Blender.app/Contents/MacOS
./Blender
```

If you need to do this often, you can add this directory to your `PATH`.

For that you can run the following procedure:

1. Open up a Terminal.
2. Run the following command: `sudo nano /etc/paths`.
3. Enter your password, when prompted.
4. Go to the bottom of the file, and enter `/Applications/Blender.app/Contents/MacOS`.
5. Enter `Ctrl`-`X` to quit.
6. Enter `Y` to save the modified buffer.

If you then open a new terminal, the following command will work:

```
Blender
```