PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use Sculpting Tools in Blender? Include parameters, examples, warnings and best practices.

assistant: # Sculpting Tools

Brush
:   Tool to use for any of the sculpting [brushes](brushes.html).

[Annotate](../../../interface/annotate_tool.html#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../../interface/annotate_tool.html#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../../interface/annotate_tool.html#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../../interface/annotate_tool.html#tool-annotate-eraser)
    :   Erase previous drawn annotations.
user: What is Drivers and how is it used in Blender Python scripting?

assistant: Upgrading to the latest graphics drivers often solves problems. Newer drivers have bug fixes that help Blender
function correctly.

On Linux, graphics drivers are usually installed as a package by your Linux distribution. Installing the latest
drivers is typically done by upgrading packages or the distribution as a whole. Some distributions provide multiple
packages for multiple drivers versions, giving you the choice to install newer versions.
user: What is Crease Angle and how is it used in Blender Python scripting?

assistant: # Crease Angle

A modifier based on the Crease Angle (angle between two adjacent faces).
If a stroke segment does not lie on a crease (i.e. the edge does not have the *Crease Angle nature*),
its properties are not touched by the modifier.

Angle Min, Max
:   The range of input values to the mapping.
    Out-of-range crease angle values will be clamped by
    the Min and Max angles and their corresponding property values.

[image reference removed]

Crease Angle modifier example by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Render_freestyle_modifier_crease_angle.blend)).
user: Show practical ways to work with Armature Modifier in a Blender add-on or script – include code.

assistant: # Armature Modifier

The *Armature* modifier is used for building skeletal systems (rigs) for animating
the poses of characters and anything else which needs to be posed.

By adding an armature system to an object,
that object can be deformed accurately so that geometry does not have to be animated by hand.
user: What is Defaults and how is it used in Blender Python scripting?

assistant: # Defaults

When you start Blender for the first time or update to a new version, the interactive region of
the [Splash Screen](../../interface/window_system/splash.xhtml) is replaced with a few initial preferences to configure
how you interact with Blender.

[image reference removed]

The initial preferences dialog.
user: Show practical ways to work with Keying Sets in a Blender add-on or script – include code.

assistant: # Keying Sets

[image reference removed]

The Active Keying Sets data ID in the Timeline.

Keying Sets are a collection of animated properties that are used to animate
and keyframe multiple properties at the same time.
For example, pressing `K` in the 3D Viewport will bring up the available Keying Sets.
Blender will then add keyframes for whichever Keying Set is chosen.
There are some built-in Keying Sets and also custom Keying Sets called “Absolute Keying Sets”.
user: Describe Node Wrangler from the Blender manual or Python API, including usage steps and snippets.

assistant: # Node Wrangler

Node Wrangler provides various tools that help you to work with nodes quickly and efficiently.

While many of this add-on’s functions work in all supported node editors (Compositor, Shader, Geometry Nodes,
and Texture Nodes) some functions only work in specific node editors, and some functions work differently per
editor.
Functions that only work in specific editors are marked with labels (Compositor, Shader,
Geometry Nodes, Texture Nodes). Functions without labels should work for all node editors.
user: Explain NodeTreeInterfaceSocketFloat(NodeTreeInterfaceSocket) in complete detail according to the official Blender documentation.

assistant: # NodeTreeInterfaceSocketFloat(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.NodeTreeInterfaceSocketFloat(*NodeTreeInterfaceSocket*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float in [-inf, inf], default 0.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 Nla Mode Extend Items in a Blender add-on or script – include code.

assistant: # Nla Mode Extend Items

NOTHING:
:   Nothing.

    Strip has no influence past its extents.

HOLD:
:   Hold.

    Hold the first frame if no previous strips in track, and always hold last frame.

HOLD_FORWARD:
:   Hold Forward.

    Only hold last frame.
user: What is Roll Hair Curves and how is it used in Blender Python scripting?

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

assistant: All field nodes work in the context of the data flow node they are connected to.
The context usually consists of a geometry component type and an attribute domain,
so it determines what data is retrieved from input nodes.

One common misunderstanding is that the same field node tree used in multiple places will
output the same data. This is not necessarily true, because the field node tree will be evaluated
for every data flow node, potentially retrieving data from a different or changed geometry.

[image reference removed]

Here, the [Set Position](geometry/write/set_position.html) node’s
input field is evaluated once. To evaluate the field, the node traverses
backwards to retrieve the inputs from the field input nodes.

[image reference removed]

When a second Set Position node is added, the same field node tree is evaluated twice, once for each data flow node.
At the second Set Position node, the results will be different since its geometry input will already have
the changed position from the first node.

[image reference removed]

However, often it’s necessary to use the same field values even after changing the geometry.
The [Capture Attribute Node](attribute/capture_attribute.html) evaluates a field, copying
the result to an [anonymous attribute](attributes_reference.html#anonymous-attributes) on the geometry.

Here, a Capture Attribute node stores a copy of the initial position.
Notice that evaluating the field input of the Capture Attribute node is an entirely
different step. Later on, the input fields to the Set Position nodes don’t use
the actual position, but the anonymous attribute copy of it.
user: Provide the full official documentation entry for Crease Angle, preserving all code examples.

assistant: # Crease Angle

A modifier based on the Crease Angle (angle between two adjacent faces).
If a stroke segment does not lie on a crease (i.e. the edge does not have the *Crease Angle nature*),
its properties are not touched by the modifier.

Angle Min, Max
:   The range of input values to the mapping.
    Out-of-range crease angle values will be clamped by
    the Min and Max angles and their corresponding property values.

[image reference removed]

Crease Angle modifier example by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Render_freestyle_modifier_crease_angle.blend)).
user: What is Properties and how is it used in Blender Python scripting?

assistant: Mode
:   Points:
    :   The position and radius of the circle are determined by three points.
        The center of the circle is also given as an output.
        If the three points lie on one line, no geometry is generated.

    Radius:
    :   The circle is determined by the radius.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Geometry
:   Standard geometry input.

Selection
:   A boolean field input for each element indicating whether to store the attribute value for the given index.
    If the attribute does not exist, unselected parts are filled with zero values;
    otherwise, only the selected parts are filled.

Value
:   The input field to evaluate.

Name
:   The name to give the stored data.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Gradient
:   A vector grid representing the gradient of the input field.
    Each vector points toward the direction of greatest increase in the scalar
    value, with its length corresponding to the rate of change.
user: Explain Elements in complete detail according to the official Blender documentation.

assistant: Cube
:   The gray cube in the center of the scene is a [mesh](../../modeling/meshes/index.xhtml) object.
    Its orange outline indicates that it’s selected.
    The orange dot in the center is its [Origin](../../scene_layout/object/origin.xhtml),
    which indicates its precise location.

Light
:   The set of concentric black circles is a [light source](../../render/lights/light_object.xhtml)
    illuminating the cube.

Camera
:   The pyramid with a big triangle above it is the [camera](../../render/cameras.xhtml),
    which is used as the point of view for rendering.

3D Cursor
:   The [3D cursor](3d_cursor.xhtml), a cross with a red-and-white circle,
    determines where newly added objects are placed and can also serve as a
    transformation [pivot point](controls/pivot_point/index.xhtml).

Grid Floor
:   The gray lines forming a floor mark the zero height of the world.
    The red and green lines are the axes of the world coordinate system.
    They meet at the world origin, which is also where the origin of the *Cube* is located.
    The Grid Floor settings are in the [Viewport Overlays](display/overlays.xhtml) popover.

### Text Info

The top left corner of the viewport shows various bits of information –
see [Viewport Overlays](display/overlays.xhtml) for details.
user: What is Handles & Interpolation Mode Display and how is it used in Blender Python scripting?

assistant: Dope Sheet can display the Bézier handle type associated with the keyframe,
and mark segments with non-Bézier interpolation.
This facilitates basic editing of interpolation without the use of the Graph Editor.

The icon shape represents the type of the [Bézier Handles](../../editors/graph_editor/fcurves/properties.html#editors-graph-fcurves-settings-handles)
belonging to the keyframe.

[image reference removed]

From top: summary, Bézier, linear.

|  |  |
| --- | --- |
| Circle | Auto Clamped (default) |
| Circle With Dot | Automatic |
| Square | Vector |
| Clipped Diamond | Aligned |
| Diamond | Free |

If the handles of a keyframe have different types,
or in case of summary rows representing multiple curves,
out of the available choices the icon that is furthest down the list is used.
This means that if a grouped row uses a circle icon,
it is guaranteed that none of the grouped channels have a non-auto key.

Horizontal green lines mark the use of
non-Bézier [Interpolation](../../editors/graph_editor/fcurves/properties.html#editors-graph-fcurves-settings-interpolation).
The line is dimmed in summary rows if not all grouped channels have the same interpolation.

Display of this information can be disabled via the *Show Handles and Interpolation*
option of the Dope Sheet’s [View Menu](../../editors/dope_sheet/navigating.html#dope-sheet-view-menu).
user: How do I use Group in Blender? Include parameters, examples, warnings and best practices.

assistant: # Group

A [Group Node](../../../interface/controls/nodes/groups.xhtml) combines a set of nodes into a single one,
and selectively exposes inputs and outputs of those nodes.

Group nodes can simplify a node tree by hiding away complexity and reusing functionality.
user: Explain CompositorNodeTrackPos(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeTrackPos(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.CompositorNodeTrackPos(*CompositorNode*)
:   Provide information about motion tracking points, such as x and y values

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

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

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Cylinder and how is it used in Blender Python scripting?

assistant: Creates a cylindrical mesh composed of two circular ends and vertical faces.
This shape is commonly used to model objects like handles, rods, pillars, and barrels.

Vertices
:   Number of vertices used to define the circular ends.
    Higher values result in a smoother circular profile.

Radius
:   Radius of the cylinder’s circular ends, measured from the center to the perimeter.

Depth
:   Height of the cylinder along the Z axis.

Cap Fill Type
:   Determines how the top and bottom of the cylinder are filled:

    Nothing:
    :   No end caps are added. Only the side faces are created, forming a tube.
        Useful for modeling pipes or hollow containers.

    N-gon:
    :   Each end is filled with a single N-gon face.

    Triangle Fan:
    :   Each end is filled with triangular faces sharing a central vertex.
user: Explain Duplicate Linked in complete detail according to the official Blender documentation.

assistant: # Duplicate Linked

You also have the choice of creating a *Linked Duplicate* rather than a *Duplicate*;
this is called a deep link. This will create a new object with **all** of its data linked to
the original object. If you modify one of the linked objects in *Edit Mode*,
all linked copies are modified. Transform properties (object data-blocks) still remain copies,
not links, so you still can rotate, scale, and move freely without affecting the other copies.
Reference the [Examples](#examples) for the discussions below.

If the original object was animated, the duplicate will link to the same [Action](../../../animation/actions.xhtml#bpy-types-action).
This means that, even though each object has separate transform properties,
they will be set to the same values by the animation system.
If this is not desired, make the action a single-user copy in the
[Action](../../../editors/dope_sheet/modes/action.xhtml) or
[NLA Editor](../../../editors/nla/introduction.xhtml).

Linked
:   In the *Duplicate Objects* [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel the *Linked* checkbox is checked
    unlike with *Duplicate*.
user: Give a detailed overview of Light: syntax, arguments, return values, common patterns.

assistant: [Light settings](../lights/light_object.xhtml) for all renderers.

### Beam Shape

Spread Area Lights
:   How wide the emitted light fans out controlling how diffused the area light is.
    Larger values create soft shadows while smaller values create sharper light
    simulating a [gridded softbox](https://en.wikipedia.org/wiki/Softbox).

    [image reference removed]

    Example of Spread at different angles.
user: How do I use Mesh Elements in Blender? Include parameters, examples, warnings and best practices.

assistant: pes.BMLoop")

    tag
    :   Generic attribute scripts can use for own logic

        Type:
        :   bool

    uv_select_edge
    :   UV selected state of this element.

        Type:
        :   bool

    uv_select_vert
    :   UV selected state of this element.

        Type:
        :   bool

    vert
    :   The loop’s vertex (read-only).

        Type:
        :   [`bmesh.types.BMVert`](#bmesh.types.bmesh.types.BMVert "bmesh.types.bmesh.types.BMVert")
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Type
:   Shape of the influence volume. Can be set to Sphere or Box.

Radius / Size
:   A probe object only influences the lighting of nearby surfaces.
    This influence zone is defined by the size parameter and object scaling.

Falloff
:   Percentage of the influence distance in which the influence of a probe fades linearly.

### Capture

Clipping Start, End
:   Define the near and far clip distances when capturing the scene.

### Custom Parallax

By default, the influence volume is also the parallax volume.
The parallax volume is a volume on which the recorded light is projected.
It should roughly fit it surrounding area. In some cases it may be better to
adjust the parallax volume without touching the influence parameters.
In this case, enable the *Custom Parallax* and
change the shape and radius of the parallax volume independently.

### Viewport Display

Data
:   Show the captured light using a reflective sphere of the given size.

Clipping
:   Show the clipping distance in the 3D Viewport.

Influence
:   Show the influence bounds in the 3D Viewport. The inner sphere is where the falloff starts.

Parallax
:   Show the *Custom Parallax* shape in the 3D Viewport.
user: What is World Environment and how is it used in Blender Python scripting?

assistant: # World Environment

[image reference removed]

Lighting with an HDR image.

The world defines the environment that the scene is in.
The surface shader sets the background and environment lighting,
either as a fixed color, sky model or HDRI texture.
With volume shaders the entire scene can be covered in mist or other volumetric effects.
user: Provide the full official documentation entry for Downloading the Repository, preserving all code examples.

assistant: Simply check out the Blender Manual’s repository using:

```
cd ~
git clone https://projects.blender.org/blender/blender-manual.git
```

The repository will now be downloaded which may take a few minutes depending on your internet connection.
user: Describe Image Type All Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Image Type All Items

JPEG:
:   JPEG (.jpg).

    Output image in JPEG format.

OPEN_EXR:
:   OpenEXR (.exr).

    Output image in OpenEXR format.

PNG:
:   PNG (.png).

    Output image in PNG format.

WEBP:
:   WebP (.webp).

    Output image in WebP format.

---

BMP:
:   Bitmap (.bmp).

    Output image in bitmap format.

CINEON:
:   Cineon (.cin).

    Output image in Cineon format.

DPX:
:   DPX (.dpx).

    Output image in DPX format.

IRIS:
:   Iris (.rgb).

    Output image in SGI IRIS format.

JPEG2000:
:   JPEG 2000 (.jp2).

    Output image in JPEG 2000 format.

HDR:
:   Radiance HDR (.hdr).

    Output image in Radiance HDR format.

TARGA:
:   Targa (.tga).

    Output image in Targa format.

TARGA_RAW:
:   Targa Raw (.tga).

    Output image in uncompressed Targa format.

TIFF:
:   TIFF (.tif).

    Output image in TIFF format.

OPEN_EXR_MULTILAYER:
:   OpenEXR MultiLayer (.exr).

    Output image in multilayer OpenEXR format.

FFMPEG:
:   FFmpeg Video.
user: Describe Handle Type Selection Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Handle Type Selection Node

[image reference removed]

Creates a selection based on the handle types of the control points.

The handle type of each control point can be changed with the
[Set Handle Type Node](../write/set_handle_type.html).
user: What is Select Grouped and how is it used in Blender Python scripting?

assistant: You can select bones, based on various properties, through the *Select Grouped* pop-up menu `Shift`-`G`:

Collection
:   Selects all bones that are share at least one bone collection with the active bone.

Color
:   Selects all bones that have the same color as the active bone.

Keying Set
:   All bones affected by active [Keying Set](../../keyframes/keying_sets.html)

Children
:   Select all children of currently selected bones.

Immediate Children
:   Select direct children of currently selected bones.

Parents
:   Select the parents of currently selected bones.

Siblings
:   Select all bones that have the same parent as currently selected bones.
user: Provide the full official documentation entry for Depth of Field, preserving all code examples.

assistant: # Depth of Field

To render a scene, EEVEE uses a pinhole camera model which produces
a perfectly focused image of the scene. For an enhanced realism, EEVEE can simulate
the optical [Depth of Field](../../../glossary/index.xhtml#term-Depth-of-Field) using a post-process filter, and a sample-based method.
The optical settings are located in the [camera settings](../../cameras.xhtml) properties.
Whereas the quality of the effect can be controlled by the settings found in the present section.

The post-process method is computed in two passes.
The first pass is using a blur that fails to produce quality bokeh for highlights but works for the general case.
Followed by a second pass which is sprite-based and improves only the quality of very bright highlights.
That is because it is too slow to be applied on every part of the image.
So it just includes very bright isolated parts of the image such that are different from their surroundings.
Which pixels are being processed by second pass can be control with
the *Sprite Threshold* and *Neighbor Rejection* options.

Secondly the sample-based method works by randomizing the camera position for every sample.
It is more accurate but needs many samples to achieve a smooth result.
Accordingly the post-process blurring radius is scaled down to remove undersampling.
Yet some scenes might still need more post-process blur in order to remove the noticeable sample pattern.
This is exactly what the *Overblur* option does, but it will also reduce the bokeh shape sharpness.

Max Size
:   Maximum size in pixels of the depth of field post-process effect (lower is faster).
    A value of 0 will disable the post-process effect but not the sample-based method.

Sprite Threshold
:   Minimum brightness a pixel needs to have to be considered by the sprite-based depth of field.
    Higher values will improve the performance but will also reduce the quality of highlights.
    Brightness is in the scene’s referred color space.

Neighbor Rejection
:   Maximum intensity to consider when doing sprite neighborhood rejection.
    This should be set to a brightness value above which there is
    small visual differences to be noticeable after color management.
    Lower values will improve the performance but will also reduce the quality of highlights.
    Brightness is in the scene’s referred color space.

Jitter Camera
:   Randomize the camera position for every scene render sample to increase precision.
    Enabling this option can change the scene’s actual sample count.

Over-blur
:   Scales the post-process depth of field radius to reduce artifacts. Higher values will soften the bokeh shape.
user: What is Dt Layers Select Src Items and how is it used in Blender Python scripting?

assistant: # Dt Layers Select Src Items

ACTIVE:
:   Active Layer.

    Only transfer active data layer.

ALL:
:   All Layers.

    Transfer all data layers.

BONE_SELECT:
:   Selected Pose Bones.

    Transfer all vertex groups used by selected pose bones.

BONE_DEFORM:
:   Deform Pose Bones.

    Transfer all vertex groups used by deform bones.
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Bevel Edges* tool works only on selected edges with exactly two adjacent faces.
It will recognize any edges included in a vertex or face selection as well,
and perform the bevel the same as if those edges were explicitly selected.
In “vertex only” mode, the *Bevel Vertices* tool works on selected vertices instead of edges,
and there is no requirement about having any adjacent faces.
The *Bevel* tool smooths the edges and/or “corners” (vertices)
by replacing them with faces making smooth profiles with a specified number of *segments*
(see the options below for details about the bevel algorithm).

Use `Ctrl`-`B` or a method listed above to run the tool.
Move the mouse to interactively or type a number to specify the bevel offset,
and scroll the `Wheel` to increase or decrease the number of segments (see below).

|  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_bevel_example-1.png   Selected edge before beveling. | ../../../../_images/modeling_meshes_editing_edge_bevel_example-2.png   Result of bevel (one segment). | ../../../../_images/modeling_meshes_editing_edge_bevel_example-3.png   Result of bevel (vertex only). |
user: Show practical ways to work with CompositorNodeSeparateColor(CompositorNode) in a Blender add-on or script – include code.

assistant: # CompositorNodeSeparateColor(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.CompositorNodeSeparateColor(*CompositorNode*)
:   Split an image into its composite color channels

    mode
    :   Mode of color processing

        - `RGB`
          RGB – Use RGB (Red, Green, Blue) color processing.
        - `HSV`
          HSV – Use HSV (Hue, Saturation, Value) color processing.
        - `HSL`
          HSL – Use HSL (Hue, Saturation, Lightness) color processing.
        - `YCC`
          YCbCr – Use YCbCr (Y - luma, Cb - blue-difference chroma, Cr - red-difference chroma) color processing.
        - `YUV`
          YUV – Use YUV (Y - luma, U V - chroma) color processing.

        Type:
        :   enum in [`'RGB'`, `'HSV'`, `'HSL'`, `'YCC'`, `'YUV'`], default `'RGB'`

    ycc_mode
    :   Color space used for YCbCrA processing

        Type:
        :   enum in [`'ITUBT601'`, `'ITUBT709'`, `'JFIF'`], default `'ITUBT601'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is ShaderNodeVectorRotate(ShaderNode) and how is it used in Blender Python scripting?

assistant: # ShaderNodeVectorRotate(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.ShaderNodeVectorRotate(*ShaderNode*)
:   Rotate a vector around a pivot point (center)

    invert
    :   Invert the rotation angle

        Type:
        :   boolean, default False

    rotation_type
    :   Type of angle input

        - `AXIS_ANGLE`
          Axis Angle – Rotate a point using axis angle.
        - `X_AXIS`
          X Axis – Rotate a point using X axis.
        - `Y_AXIS`
          Y Axis – Rotate a point using Y axis.
        - `Z_AXIS`
          Z Axis – Rotate a point using Z axis.
        - `EULER_XYZ`
          Euler – Rotate a point using XYZ order.

        Type:
        :   enum in [`'AXIS_ANGLE'`, `'X_AXIS'`, `'Y_AXIS'`, `'Z_AXIS'`, `'EULER_XYZ'`], default `'AXIS_ANGLE'`

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

assistant: Depending on the [selection mode](introduction.xhtml#bpy-types-toolsettings-mesh-select-mode),
this operator selects vertices that are not part of any edge, edges that are not
part of any face, or faces that do not share an edge with any other face.
user: Show practical ways to work with Operator Buttons in a Blender add-on or script – include code.

assistant: [image reference removed]

Operator button.

Operator buttons execute an [Operator](../../operators.html)
which in summary execute an action when clicked with `LMB`.
Operator buttons may be an icon, text, or text with an icon.
user: Describe Controls from the Blender manual or Python API, including usage steps and snippets.

assistant: Sculpt mode provides several properties that give advanced control of the tool’s behavior.
These options can be found in the right-hand side of the 3D Viewport’s Header.

Mirror
:   Allows tools to affect curves symmetrically according to the chosen axis.

Use Sculpt Collision
:   Prevents the curve segments from passing through the [Surface Object](../../modeling/curves_new/properties.html#bpy-types-curves-surface).
user: How do I use TextureNodeRotate(TextureNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # TextureNodeRotate(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.TextureNodeRotate(*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: How do I use Opening Images in Blender? Include parameters, examples, warnings and best practices.

assistant: Relative Path
:   Sets the file path to be relative to the currently opened blend-file.

    See [Relative Paths](../blend/open_save.html#files-blend-relative-paths).

Detect Sequences
:   Automatically looks for image sequences in the selected images (based on the file name).
    Disable this when you do want to get single images that are part of a sequence.
    See [Opening an Image Sequence](#image-formats-open-sequence) for more information.

Detect UDIMs
:   Automatically looks for [UDIM](../../modeling/meshes/uv/workflows/udims.html)
    tiles in the directory of the selected image; if matches are found they are loaded into Blender as UDIMs.
    This works by detecting if the filename has a `.xxxx` (four digit number) before the file extension.

### Opening an Image Sequence

To load image sequence in any of the supported image file formats,
the filename of the images must contain a digit to indicate the frame order
(e.g. `*-0001.jpg`, `*-0002.jpg`, `*-0003.jpg`, etc, of any image format), indicating the frame.

The sequence could be opened by the selection of the images with any of the following methods
by the confirmation with the *Open Image* button or `Return`.

Range
:   Navigate into the directory and `LMB` click and drag over a range of names to highlight multiple files.
    You can page down and continue `Shift`-`LMB` click-dragging to add more to the selection.

Batch
:   `Shift`-`LMB` click selected non-related stills for batch processing; each image will be one frame,
    in sort order, and can be a mix of file types (`jpg`, `png`, `exr`, etc.).

All
:   Press `A` to select/deselect all files in the directory.
user: Describe GeometryNodeMeshToSDFGrid(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeMeshToSDFGrid(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.GeometryNodeMeshToSDFGrid(*GeometryNode*)
:   Create a signed distance volume grid from a mesh

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

assistant: Geometry
:   The input geometry to displace.

Selection
:   Determines which elements of the geometry are affected by the displacement.
    Unselected elements remain unchanged.

Strength
:   The distance to move each element along the chosen offset direction or vector.

Offset Method
:   Determines how the displacement direction is defined.

    Normal:
    :   Offsets elements along their surface normal direction.

    Vector:
    :   Offsets elements according to a custom input vector.

Offset Distance Normal
:   The displacement distance when using *Normal* mode.

Offset Vector Vector
:   The displacement vector when using *Vector* mode.
    The vector is normalized internally unless otherwise specified.

Substeps
:   The number of intermediate steps to divide the displacement into.
    Fields, including normal and position, are re-evaluated at each substep for more stable
    or accurate iterative results.

Post Substep Process
:   A [Node Closures](../../utilities/closure/index.xhtml)
    that defines a geometry operation to apply after each substep of the displacement.
    This allows additional geometry processing to be performed during the iterative displacement.

    The closure has the following parameters:

    - **Geometry** – The geometry at the current substep.
    - **Selection** – The selected elements at that stage.
    - **Strength** – The displacement strength for the substep.
    - **Substep Index** – The current substep iteration number.
user: Show practical ways to work with Animating Stabilization Parameters in a Blender add-on or script – include code.

assistant: Animating some parameters over duration of the shot is often necessary, at least to get the final touch,
including control of the scale factor to hide the dancing black borders.
Unfortunately there is a **known limitation** in the current version:
it is not possible to open the generic animation editors (Graph editor and Dope Sheet)
for animation data beyond the 3D scene. So, while it *is possible* to set keyframes *right within the UI controls*
of the stabilizer (either through pressing the `I` key or with the help of the context menu),
it is not possible to manipulate the resulting curves graphically.
The only way to readjust or remove a misguided keyframe is to locate
the timeline to the very frame and then use the context menu of the animated UI control.
(Hint: the color of the UI control changes when you have located at precisely the frame number of the keyframe.)
user: Explain Hue/Saturation Tips in complete detail according to the official Blender documentation.

assistant: Some things to keep in mind that might help you use this node better:

Hues are laid out on a circle
:   If you apply a Hue offset of 1 (+180°) to a blue image, you get the diametrically opposite
    color, which is yellow. If you apply a Hue offset of 1 to that yellow image, you get blue again.

Grayscale images have no hue
:   Trying to change the Hue or Saturation of a grayscale image has no effect. You can only brighten
    or darken it by adjusting the Value. To add color, use the Mix node instead.

Changing the effect over time
:   The different values can be animated using a *Time Curve* node or by setting keyframes.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Closures define their own inputs, which act as parameters for the internal node logic.
These inputs can be created by dragging the blank input socket into another socket or by adding sockets manually in the
node’s properties. Each input defines a parameter that the closure can receive when it is evaluated elsewhere.
user: Provide the full official documentation entry for FloatVectorAttribute(Attribute), preserving all code examples.

assistant: # FloatVectorAttribute(Attribute)

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

*class* bpy.types.FloatVectorAttribute(*Attribute*)
:   Geometry attribute that stores floating-point 3D vectors

    data
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`FloatVectorAttributeValue`](bpy.types.FloatVectorAttributeValue.html#bpy.types.FloatVectorAttributeValue "bpy.types.FloatVectorAttributeValue"), (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: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Closure
:   The closure to evaluate.
    This input expects a connection from a [Closure Zone](../../../interface/controls/nodes/types/utilities/closure/closure.html).
    If no closure is connected, the node operates in *pass-through mode* (see below).

### Interface

The node can define additional inputs manually, which are matched by name to the corresponding inputs of the connected
closure. When the closure is connected, these sockets automatically sync to reflect the closure’s defined interface.
user: Describe Managing Preferences from the Blender manual or Python API, including usage steps and snippets.

assistant: Default preferences are managed from the ☰ menu in the preferences window.

The following items are available in this menu:

Auto-Save Preferences
:   By default changes to preferences are saved on exit,
    this allows changes to the keymap and Quick Favorites menu to be stored and used between
    [Blender Sessions](../../glossary/index.xhtml#term-Blender-Session).

    When disabled, a *Save Preferences* button is shown to manually perform the operation.

Revert to Saved Preferences
:   Undoes any unsaved modifications, loading the previously saved state.

Load Factory Preferences
:   Completely undo all the modifications made to the preferences,
    resetting to the state used before making customizations.
user: Explain Preview in complete detail according to the official Blender documentation.

assistant: # Preview

The Preview panel gives a quick visualization of the active material applied in a simple scene.

Shape
:   Preview the material on a Plane, Sphere, Cube, Hair, Shader Ball, Cloth or Fluid object.
    This shape is also used for previews when linking and appending materials.

Preview World Cycles Only
:   Use the world from the current scene for lighting in the material preview.

[image reference removed]

Preview shapes.