PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for CurveMap(bpy_struct), preserving all code examples.

assistant: # CurveMap(bpy_struct)

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

*class* bpy.types.CurveMap(*bpy_struct*)
:   Curve in a curve mapping

    points
    :   Type:
        :   [`CurveMapPoints`](bpy.types.CurveMapPoints.html#bpy.types.CurveMapPoints "bpy.types.CurveMapPoints") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`CurveMapPoint`](bpy.types.CurveMapPoint.html#bpy.types.CurveMapPoint "bpy.types.CurveMapPoint"), (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: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Samples
:   Number of samples to use for ray-traced ambient occlusion sampling.
    Keep as low as possible for optimal performance.

Inside
:   Detect convex rather than concave shapes, by computing occlusion inside mesh.

Only Local Cycles Only
:   Only detect occlusion from the object itself, and not others.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Corner Index
:   The geometry-wide index of the selected corner. You can pass this to the
    [Evaluate at Index Node](../../utilities/field/evaluate_at_index.html) or the
    [Sample Index Node](../../geometry/sample/sample_index.html) (with the domain set to Face Corner)
    to retrieve details about the corner.

Total
:   The number of adjacent corners, which is also the number of faces.
user: What is Interpolate and how is it used in Blender Python scripting?

assistant: # Interpolate

The *Interpolate* tool creates an in-between keyframe
by interpolating strokes between the previous and next Grease Pencil keyframes.
When used on a frame between two keyframes, clicking and dragging will add a new *breakdown* keyframe,
interpolating the stroke’s shape based on the drag distance.

This allows artists to manually control how strokes evolve between poses or drawings,
providing fine control over the interpolation result.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Curve Index
:   The index of the input curve.

Weights
:   Values used to sort the curve’s control points.
    By default the control points are sorted by index, so the control points with the smallest indices come first.

Sort Index
:   Which of the sorted control points to use for the *Point Index* output. If the value is larger than
    the total number of control points, it will wrap around to the beginning.
user: Give a detailed overview of NodeJoinBundle(NodeInternal): syntax, arguments, return values, common patterns.

assistant: # NodeJoinBundle(NodeInternal)

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

*class* bpy.types.NodeJoinBundle(*NodeInternal*)
:   Join multiple bundles together

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: With a node group selected, press `Tab` to move into it and see its content.
Press `Tab` again (or `Ctrl`-`Tab`) to leave the group and go back to
its parent, which could be the top-level node tree or another node group.
You can refer to the breadcrumbs in the top left corner of the node editor
to see where you are in the hierarchy.

[[image reference removed]](../../../_images/render_cycles_optimizations_reducing-noise_glass-group.png)

Example of an expanded node group.
user: Provide the full official documentation entry for Fingers Bones, preserving all code examples.

assistant: Start by placing, finger by finger, all the knuckles in place.

[image reference removed]

Knuckles Edge Loops and Cursor Snapping.

Finalize the positioning by taking care of bone rolls (the X axis is set as bend axis).

[image reference removed]

Fingers Bend Axis.

When the fingers are in place proceed placing the palm bones.

[image reference removed]

Palm Alignment.
user: Explain GeometryNodeWarning(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeWarning(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.GeometryNodeWarning(*GeometryNode*)
:   Create custom warnings in node groups

    warning_type
    :   Type:
        :   enum in [Node Warning Type Items](bpy_types_enum_items/node_warning_type_items.html#rna-enum-node-warning-type-items), default `'ERROR'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Strip Scale Method Items and how is it used in Blender Python scripting?

assistant: # Strip Scale Method Items

FIT:
:   Scale to Fit.

    Fits the image bounds inside the canvas, avoiding crops while maintaining aspect ratio.

FILL:
:   Scale to Fill.

    Fills the canvas edge-to-edge, cropping if needed, while maintaining aspect ratio.

STRETCH:
:   Stretch to Fill.

    Stretches image bounds to the canvas without preserving aspect ratio.

ORIGINAL:
:   Use Original Size.

    Display image at its original size.
user: Provide the full official documentation entry for Split, preserving all code examples.

assistant: Disconnects the selected sub grid from the rest of the surface, keeping it within
the same Surface object. The control points at the border are duplicated so that both
the original surface and the disconnected surface have them.

The sub grid must consist of one or more complete rows or columns of the surface grid.
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Anywhere the geometry is a curve, this node can be used to generate a selection of
only the first and last points of each spline. Here, the *Points* input of
the [Instance on Points Node](../../instances/instance_on_points.html) is a curve
consisting of the poly spline shown in Edit Mode.
user: How do I use Filter Tools in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Tools for applying effects on the entire unmasked and visible mesh.

[Mesh Filter](tools/mesh_filter.html)
:   Apply a deformation to all unmasked vertices.

[Cloth Filter](tools/cloth_filter.html)
:   Applies a cloth simulation to all unmasked vertices.

[Color Filter](tools/color_filter.html)
:   Changes the active color attribute on all unmasked vertices.
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |  |
| --- | --- | --- |
| <../../../_images/modeling_modifiers_deform_curve_example-edit-curve.png>   Edit curve. | <../../../_images/modeling_modifiers_deform_curve_example-monkeyoncurve1.png>   Monkey on a curve. | <../../../_images/modeling_modifiers_deform_curve_example-monkeyoncurve2.png>   Monkey deformations. |
user: Give a detailed overview of Corner Pin Node: syntax, arguments, return values, common patterns.

assistant: # Corner Pin Node

[image reference removed]

The Corner Pin node uses explicit corner values for a plane warp transformation.
It works like the [Plane Track Deform](../tracking/plane_track_deform.html) node,
but without using “plane track” data from the Movie Clip Editor.
user: Explain String to Curves Node in complete detail according to the official Blender documentation.

assistant: # String to Curves Node

[image reference removed]

The *String to Curves* node converts a string to curve instances. Each unique character used in the string
is converted to a curve once, and further uses of that character are instances of the same geometry.
The name of each instance geometry is the character it represents.

This makes processing the output geometry very efficient, because each unique character
only has to be processed once. However, it means that the result will be the same
for every instance of the same character. To process each character individually,
the [Realize Instances Node](../../instances/realize_instances.xhtml) can be used.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Value
:   The values the minimum and maximum will be calculated from

Group ID
:   An index used to group values together for multiple separate averages.
    This can be thought of as a choice of the “bin” in which to place each value.
    This input has no effect when it is only a single value.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Image
:   Standard color input.

Channel
:   Selects which color values are used to calculate analytics.

    Combined:
    :   Calculate values based on the red, green, and blue channels.

    Red:
    :   Calculate values based on the red channel.

    Green:
    :   Calculate values based on the green channel.

    Blue:
    :   Calculate values based on the blue channel.

    Luminance:
    :   Calculate values based on the [Luminance](../../../glossary/index.xhtml#term-Luminance) of the image.
user: How do I use Maximize Area in Blender? Include parameters, examples, warnings and best practices.

assistant: Expands the editor area so it fills the whole window, while keeping the Topbar and Status Bar visible.
This is useful for focusing on a single editor (e.g. 3D Viewport, Shader Editor) without changing your workspace
layout.

In the 3D Viewport, maximizing the area temporarily hides:

- [Navigation Gizmos](../../editors/3dview/navigate/introduction.html#navigation-gizmo)
- [Text Info](../../editors/3dview/display/overlays.html#bpy-types-view3doverlay-show-text) overlay
- [Statistics](../../editors/3dview/display/overlays.html#bpy-types-view3doverlay-show-stats) overlay

To return to normal size, use the shortcut again or click the *Back to Previous* button in the Topbar.
user: Provide the full official documentation entry for SequencerTimelineOverlay(bpy_struct), preserving all code examples.

assistant: # SequencerTimelineOverlay(bpy_struct)

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

*class* bpy.types.SequencerTimelineOverlay(*bpy_struct*)
:   show_fcurves
    :   Display strip opacity/volume curve

        Type:
        :   boolean, default False

    show_grid
    :   Show vertical grid lines

        Type:
        :   boolean, default False

    show_strip_duration
    :   Type:
        :   boolean, default False

    show_strip_name
    :   Type:
        :   boolean, default False

    show_strip_offset
    :   Display strip in/out offsets

        Type:
        :   boolean, default False

    show_strip_retiming
    :   Display retiming keys on top of strips

        Type:
        :   boolean, default False

    show_strip_source
    :   Display path to source file, or name of source data-block

        Type:
        :   boolean, default False

    show_strip_tag_color
    :   Display the strip color tags in the sequencer

        Type:
        :   boolean, default False

    show_thumbnails
    :   Show strip thumbnails

        Type:
        :   boolean, default False

    waveform_display_style
    :   How Waveforms are displayed

        - `FULL_WAVEFORMS`
          Full – Display full waveform.
        - `HALF_WAVEFORMS`
          Half – Display upper half of the absolute value waveform.

        Type:
        :   enum in [`'FULL_WAVEFORMS'`, `'HALF_WAVEFORMS'`], default `'FULL_WAVEFORMS'`

    waveform_display_type
    :   How Waveforms are displayed

        - `ALL_WAVEFORMS`
          On – Display waveforms for all sound strips.
        - `DEFAULT_WAVEFORMS`
          Strip – Display waveforms depending on strip setting.
        - `NO_WAVEFORMS`
          Off – Don’t display waveforms for any sound strips.

        Type:
        :   enum in [`'ALL_WAVEFORMS'`, `'DEFAULT_WAVEFORMS'`, `'NO_WAVEFORMS'`], default `'DEFAULT_WAVEFORMS'`

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

assistant: # ShapeKeyPoint(bpy_struct)

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

*class* bpy.types.ShapeKeyPoint(*bpy_struct*)
:   Point in a shape key

    co
    :   Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], default (0.0, 0.0, 0.0)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

Pixelate Visual Effect.

Size X, Y
:   Horizontal and vertical size of the final pixels to apply.

Anti-aliasing
:   Applies an anti-aliasing effect to the resulting pixels.
user: What is Brush Curves Sculpt Brush Type Items and how is it used in Blender Python scripting?

assistant: # Brush Curves Sculpt Brush Type Items

SELECTION_PAINT:
:   Paint Selection.

---

ADD:
:   Add.

DELETE:
:   Delete.

DENSITY:
:   Density.

---

COMB:
:   Comb.

SNAKE_HOOK:
:   Snake Hook.

GROW_SHRINK:
:   Grow / Shrink.

PINCH:
:   Pinch.

PUFF:
:   Puff.

SMOOTH:
:   Smooth.

SLIDE:
:   Slide.
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Root Selection
:   A boolean selection that is `true` only for the root points of curves.
    This is useful for applying operations exclusively at the curve base.

Root Position
:   The position of each curve’s root point in 3D space.
    This can be used for aligning objects, sampling data from a surface, or generating root-based effects.

Root Direction
:   A normalized vector representing the direction of the first segment of the curve,
    pointing away from the root toward the next control point.
    This is useful for orienting instances or determining the initial growth direction of the curve.

Root Index
:   The index of the root point for each curve.
    This is typically 0 for every curve, but it can be used to identify root points
    when processing multiple curves together.
user: Show practical ways to work with FunctionNodeInputString(FunctionNode) in a Blender add-on or script – include code.

assistant: # FunctionNodeInputString(FunctionNode)

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

*class* bpy.types.FunctionNodeInputString(*FunctionNode*)
:   Provide a string value that can be connected to other nodes in the tree

    string
    :   Type:
        :   [string](#bpy.types.FunctionNodeInputString.string "bpy.types.FunctionNodeInputString.string"), default “”, (never None)

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Push/Pull

[image reference removed]

Push/Pull distance.

Moves the selected elements closer to (Push) or further away from (Pull) the pivot point,
all by the same distance. You can control this distance by moving the mouse up or down,
typing a number, or using the slider in the [Adjust Last Operation](../../../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel.
user: Provide the full official documentation entry for Main View, preserving all code examples.

assistant: The X axis represents time, with the numbers 0/50/100/… being frame numbers.
The blue line is the *Playhead* indicating the current frame,
and the diamond shapes are *Keyframes*, points where you specified
a certain value for a certain property at a certain time.

### Adjusting the View

Panning is done by dragging `MMB`.

Zooming is done by dragging `Ctrl`-`MMB`, rolling the mouse `Wheel`,
or pressing `NumpadMinus`/`NumpadPlus`.

You can also use the scrollbars located at the bottom and the right of the editor.

### Frame Range

The *Frame Range* determines the length of the scene’s animation.
By default, it’s set to start at frame 1 and end at frame 250.
You can change this using the Start/End inputs in the Timeline header,
or in the [Output Properties](../render/output/properties/frame_range.xhtml).

### Keyframes

By default, the timeline only shows keyframes for selected items.
You can make it show all keyframes by unchecking
View ‣ Only Show Selected.

You can click a keyframe to select it (and deselect all others),
or click it while holding `Shift` to add it to the selection
(or remove it if it was already selected). You can also drag a box
to select multiple keyframes in one go.

To move the selected keyframes, simply drag one of them. Alternatively,
you can press `G`, move the mouse, and click `LMB` to confirm
(or `RMB` to cancel). You can also press `S` to scale the keyframes
in relation to the Playhead.

### Markers

See the [Markers page](../animation/markers.xhtml) for more information.
user: Show practical ways to work with Bevel in a Blender add-on or script – include code.

assistant: Apply a Bevel to turn the 1D line (or 2D ribbon when using [Extrude](#bpy-types-curve-extrude))
into a 3D tube.

### Round

The cross section of the tube becomes a circle (or pill when using Extrude).
You can also get a half circle by changing the [Fill Mode](shape.html#bpy-types-curve-fill-mode).

Depth
:   The size of the cross section.

    |  |  |
    | --- | --- |
    | <../../../_images/modeling_curves_properties_geometry_bevel-depth.png>   Small Depth. | <../../../_images/modeling_curves_properties_geometry_bevel.png>   Large Depth. |

Resolution
:   Drives the number of vertices in the cross section.

    |  |  |
    | --- | --- |
    | <../../../_images/modeling_curves_properties_geometry_bevel-resolution.png>   A low Resolution results in a blocky mesh. | <../../../_images/modeling_curves_properties_geometry_bevel.png>   A high Resolution results in a smooth mesh. |

Fill Caps
:   Seals the ends of the tube.

### Object

This option lets you fully customize the shape of the cross section by selecting a separate Curve object.

[image reference removed]

Object
:   The curve that defines the cross section. It can be either closed ([cyclic](../editing/curve.html#bpy-ops-curve-cyclic-toggle))
    or open.

### Profile

This option lets you customize the shape of the cross section without having to create a separate
Curve object. However, unlike the *Object* option where the curve defines the full cross section,
the *Profile* in the [Curve Widget](../../../interface/controls/templates/curve.html#ui-curve-widget) only defines a quarter which is then repeated and mirrored.

[image reference removed]

The black dots on the profile represent the points where it’s sampled (that is, where mesh vertices
will be created). You can increase the *Resolution* to get more sample points, and thus a smoother result.

Preset
:   You can choose one of the predefined profiles instead of making your own.
    The *Support Loops* and *Steps* presets are generated dynamically based on the *Resolution*
    and need to be reapplied if you change it.

Reverse Path
:   Mirrors the profile around the diagonal.

Toggle Profile Clipping
:   Limits the X and Y coordinates of control points to the range [0, 1].

Sample Straight Edges
:   Whether to sample the profile in the middle of perfectly straight segments
    (lines between two control points with the *Vector* [handle type](../../../interface/controls/templates/curve.html#ui-curve-widget-handle-type)).
    This is disabled by default, as it’s normally enough to sample the profile at the control
    points themselves.

Sample Even Lengths
:   By default, each profile segment receives the same number of sample points.
    By enabling this option, the sample points are instead distributed evenly
    along the whole length of the profile.
user: Give a detailed overview of The Current File Asset Library: syntax, arguments, return values, common patterns.

assistant: To help with the management of assets in the current blend-file, you can set the Asset Browser
to show the **Current File asset library**. This always shows the assets in the current file,
even when the current file is not saved in an asset library.
This also makes it possible to create assets and use them in the same file,
for small single-file projects.

When the current blend-file is part of an asset library, you can also see its assets in that library, of course.
The assets that are in the current file are marked with an icon; only those are editable.
user: Provide the full official documentation entry for Connect Vertex Pairs, preserving all code examples.

assistant: # Connect Vertex Pairs

This operator connects selected vertices by creating edges between them and splitting the face.
It can be used on many faces at once.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_meshes_editing_vertex_connect-vertex-pairs_before.png   Vertices before connecting. | ../../../../_images/modeling_meshes_editing_vertex_connect-vertex-pairs_after.png   After connecting vertices. | ../../../../_images/modeling_meshes_editing_vertex_connect-vertex-pairs_after-faces.png   Resulting face pair. |

The main difference between this operator and [Connect Vertex Path](connect_vertex_path.xhtml)
is that this operator ignores the selection order and connects all selected vertices that share a face.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`Camera.background_images`](bpy.types.Camera.html#bpy.types.Camera.background_images "bpy.types.Camera.background_images") - [`CameraBackgroundImages.new`](bpy.types.CameraBackgroundImages.html#bpy.types.CameraBackgroundImages.new "bpy.types.CameraBackgroundImages.new") | - [`CameraBackgroundImages.remove`](bpy.types.CameraBackgroundImages.html#bpy.types.CameraBackgroundImages.remove "bpy.types.CameraBackgroundImages.remove") |
user: How do I use Memory & Limits in Blender? Include parameters, examples, warnings and best practices.

assistant: Undo Steps
:   Number of Undo steps available.

Undo Memory Limit
:   Maximum memory usage in Mb (0 is unlimited).

Global Undo
:   This enables Blender to save actions done when you are **not** in *Edit Mode*.
    For example, duplicating objects, changing panel settings or switching between modes.

Console Scroll-back Lines
:   The number of lines, buffered in memory of the console window.
    Useful for debugging purposes and command-line rendering.

Texture Time Out
:   Time since last access of a GL texture in seconds, after which it is freed.
    Set this to 0 to keep textures allocated.

    Garbage Collection Rate
    :   Number of seconds between each run of the GL texture garbage collector.

VBO Time Out
:   Time since last access of a GL vertex buffer object (VBO) in seconds after which it is freed
    (set to 0 to keep VBO allocated).

    Garbage Collection Rate
    :   Number of seconds between each run of the GL vertex buffer object garbage collector.

Shader Compilation Method
:   Defines the method used for compiling GPU shaders in parallel.

    - This option is not available on macOS and requires using OpenGL backend.
    - Changing this setting requires restarting Blender to take effect.

    Thread:
    :   Uses multiple threads within a single process to compile shaders concurrently.
        This method is more memory-efficient but may be slower on some systems.

    Subprocess:
    :   Uses multiple separate subprocesses to compile shaders in parallel.
        This can be faster, especially on systems with high core counts, but consumes significantly more RAM.

Threads / Subprocesses
:   The number of shader compilation threads or subprocesses to use.
    The maximum value is limited by the number of logical CPU cores on the system.

    Increasing the number can reduce shader compilation time at the cost of higher memory usage.
    A value of 0 lets Blender automatically choose a suitable number based on the system configuration.

    - This option is not available on macOS and requires using OpenGL backend.
    - Changing this setting requires restarting Blender to take effect.
user: Show practical ways to work with Vertex Group Categories in a Blender add-on or script – include code.

assistant: While all vertex groups are technically the same, we can still divide them into two types
depending on how they’re used:

Deform Groups
:   Also sometimes called “weight group” or “weight map,” this type of vertex group determines
    which vertices are affected by a certain bone in the
    [Armature](../../../../animation/armatures/introduction.xhtml). In other words, it defines which part
    of the mesh deforms when the bone moves around.

Other Groups
:   The remaining vertex groups are used with shape keys, modifiers, and other areas.

The deform vertex groups are related to each other: the deformation weights of every vertex
typically need to add up to 1. For this reason, you can use the filter buttons at the top
of the panel to show only these vertex groups (or to exclude them).
user: What is Selection Sets and how is it used in Blender Python scripting?

assistant: # Selection Sets

Selection Sets are a feature that allows the definition of sets of bones for easy selection while animating.
The sets can be created in local and linked armature overrides.

Selection Set
:   A [List View](../../../interface/controls/templates/list_view.html#ui-list-view) listing all selection sets for the selected armature.
    Here, selection sets can be renamed by double clicking on the name.

    To the right of the name is a check box to include that selection set when copying to the clipboard.

Specials

Delete All Sets
:   Removes all selection sets from the list.

Remove Selected Bones from All Sets
:   Removes the selected bones from all selection sets.

Copy Selected Set(s)
:   Copies the selected set to Blender’s clipboard.

Paste Selected Set(s)
:   Pastes a selection set from Blender’s clipboard.

---

Assign
:   Assigns the selected bones to the active selection set.

Remove
:   Removes the selected bones to the active selection set.

Select
:   Selects all the bones in the active selection set.

Deselect
:   Deselects all the bones in the active selection set.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Geometry
:   The input geometry containing the hair curves to be deformed.

Factor
:   Controls the overall strength of the rolling effect.
    A value of 0.0 disables the effect, while 1.0 applies the full roll.

Subdivision
:   Defines how finely each curve is subdivided before deformation.
    Higher values produce smoother and more detailed rolls but increase computational cost.

Variation Level
:   Introduces variation along the roll path by smoothing or distorting its shape.
    Higher values produce more natural and uneven rolls.

Roll Length
:   Specifies the portion of each curve (measured from the tip) that is rolled.
    Increasing this value extends the length of the coiled section.

Roll Radius
:   Determines the radius of the roll, controlling how tightly each curve is coiled.

Roll Depth
:   Adds an offset along the roll axis, producing a stretched or compressed spiral shape.

Roll Taper
:   Controls how the roll radius decreases toward the tip, tapering the spiral.

Retain Overall Shape
:   When enabled, offsets the roll along the curve’s original path to better preserve the initial flow and shape
    of the hair.

Roll Direction
:   Defines the axis around which the roll is performed (e.g., X, Y, or Z).
    This determines the orientation of the curls.

Random Orientation
:   Introduces randomization to the direction of the roll, helping to avoid uniform patterns
    and adding a more natural appearance.

Seed
:   Sets the random seed for the orientation randomization.
    Changing the value alters the distribution of curl directions while keeping the same parameters.

Preserve Length
:   When enabled, maintains the total length of each curve after deformation.
    When disabled, the curves may stretch or compress slightly as a result of rolling.
user: Provide the full official documentation entry for Direction Buttons, preserving all code examples.

assistant: [image reference removed]

Direction buttons.

Clicking with `LMB` in the sphere and dragging the mouse cursor
lets the user change the direction by rotating the sphere.

### Shortcuts

- `LMB` (drag) rotates the direction.
- `Ctrl` (while dragging) snaps to vertical & diagonal directions.
user: What is Help Menu and how is it used in Blender Python scripting?

assistant: ### Web Links

The first options of this menu provide direct links to Blender-related websites. The same links can also be found in
the [Splash Screen](../interface/window_system/splash.html#splash).

[Manual](../index.html)
:   This is a link to the Official Blender Manual (which you are now reading).

[Support](https://www.blender.org/support)
:   Links to various sites, providing both community and professional support.

[User Communities](https://www.blender.org/community/)
:   Lists of many different community sites and support venues.

[Get Involved](https://www.blender.org/get-involved)
:   Learn how to give back to the Blender community by contributing to projects or donating.

[Release Notes](https://developer.blender.org/docs/release_notes/)
:   Link to the release notes for the current Blender version.

---

[Report a Bug](https://projects.blender.org/blender/blender/issues/new?template=.gitea%2fissue_template%2fbug.yaml)
:   The Blender Bug Tracker (registration needed). For more information on bug reporting, please see
    [Reporting a Bug](../troubleshooting/report_bug.html).

### Save System Info

This extracts system information which can be useful for including in bug reports, inspecting the configuration, or
diagnosing problems.

You will be prompted to save a text file called `system-info.txt`.

It contains the following sections:

Blender
:   This section shows you the Blender version, details about the build configuration, and the path in which Blender is
    running.

Python
:   The version and path of your Python installation.

Directories
:   Paths used for scripts, data files, presets and temporary files.

    Those directories are configured using the [Preferences](../editors/preferences/file_paths.html) Editor.

FFmpeg
:   The version of the installed FFmpeg components and codecs.

Other Libraries
:   The version of other libraries used by Blender such as OpenColorIO, Alembic, USD, etc.

GPU
:   Shows the GPU vendor, version and the capabilities of your hardware and driver.

Implementation Dependent GPU Limits
:   Specific limits on GPU functions related to how the current version of Blender was compiled.

Cycles
:   The instruction sets and capabilities of each hardware render device available for use with Cycles.

Enabled Add-Ons
:   Lists add-ons currently in use along with their versions and paths.
user: How do I use Add Curves in Blender? Include parameters, examples, warnings and best practices.

assistant: # Add Curves

Used to distribute new curves on the surface mesh.
This tool requires the curve to have a [surface](../introduction.xhtml) object set.

The curves follow the surface normals. Using the interpolation options allows the brush to take the characteristics
of existing curves.
user: What is Animation Editors and how is it used in Blender Python scripting?

assistant: # Animation Editors

Blender provides a set of editors designed for creating, editing, and refining animation.
These editors let you work with keyframes, curves, non-linear actions, drivers,
video sequencing, and motion tracking as part of the animation pipeline.

Each editor serves a different purpose:

- The [Dope Sheet](../editors/dope_sheet/introduction.html) organizes and manipulates keyframes
  across multiple objects and data-blocks.
- The [Graph Editor](../editors/graph_editor/introduction.html) provides fine control over F-Curves
  to refine motion and interpolation.
- The [Nonlinear Animation (NLA) Editor](../editors/nla/introduction.html) arranges and layers animation
  actions for complex sequencing.
- The [Drivers Editor](../editors/drivers_editor.html) links properties with expressions
  for procedural animation.
- The [Movie Clip Editor](../editors/clip/introduction.html) supports motion tracking, mask editing,
  and stabilization, which can be integrated into animation and compositing workflows.
- The [Video Sequence Editor](../editors/video_sequencer/introduction.html) (VSE) combines
  rendered animations, image sequences, audio, and effects into a final movie edit.

Together, these editors form the backbone of Blender’s animation system –
from quick keyframe adjustments to advanced rigging, motion editing, visual effects integration,
and final shot assembly.

This page describes features that are shared across the different animation focused editors.
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Points
:   Generated point cloud.

Tangent
:   The normalized [curve tangent](../read/curve_tangent.xhtml) at the sampled
    position, or the direct evaluated normal in *Evaluated* mode.

Normal
:   The normal value from the evaluated curve at each result point.
    This is the same value from the [Normal Node](../../geometry/read/normal.xhtml)
    at those positions.

Rotation
:   The [Euler](../../../../glossary/index.xhtml#term-Euler) rotation build from the *Tangent* and *Normal* outputs, for convenience.
user: Describe OperatorStrokeElement(PropertyGroup) from the Blender manual or Python API, including usage steps and snippets.

assistant: # OperatorStrokeElement(PropertyGroup)

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

*class* bpy.types.OperatorStrokeElement(*PropertyGroup*)
:   is_start
    :   Type:
        :   boolean, default False

    location
    :   Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], default (0.0, 0.0, 0.0)

    mouse
    :   Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], default (0.0, 0.0)

    mouse_event
    :   Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], default (0.0, 0.0)

    pressure
    :   Tablet pressure

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

    size
    :   Brush size in screen space

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

    time
    :   Type:
        :   float in [0, inf], default 0.0

    x_tilt
    :   Pen tilt from left (-1.0) to right (+1.0)

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

    y_tilt
    :   Pen tilt from backward (-1.0) to forward (+1.0)

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Refining the Layout and how is it used in Blender Python scripting?

assistant: After using the unwrapping tools, you may want to manually tweak the UV map,
for example scaling up an area so it receives more pixels of the texture
and can thus be more detailed. You can also use [Minimize Stretch](../editing.html#bpy-ops-uv-minimize-stretch)
if the UV map is too warped compared to the 3D mesh.
user: Explain Keyboard Shortcuts in complete detail according to the official Blender documentation.

assistant: To quickly add a *Subdivision Surface* modifier to one or more objects, select the object(s) and press `Ctrl`-`1`.
That will add a Subdivision Surface modifier with *Viewport* subdivisions set to 1.
You can use other numbers too, such as `Ctrl`-`2`, `Ctrl`-`3`, etc,
to add a modifier with that number of subdivisions.
Adding a *Subdivision Surface* modifier in this fashion will not modify the *Render* subdivisions.

If an object already has a *Subdivision Surface* modifier,
doing this will simply change its subdivision level instead of adding another modifier.
user: How do I use Main Features in Blender? Include parameters, examples, warnings and best practices.

assistant: Modular rigging
:   Rigify build blocks can be mixed together to rig any character you want.
    If you need to build a character with five arms and one leg,
    Rigify can handle it for you creating all the required complex controls system
    (FK, IK, and all the relative snapping tools and the UI) in few seconds.

Nondisruptive re-rig
:   If the generated rig doesn’t fit all the features you need or, for example,
    you decide to add something more to your character (like a sixth arm or a tail),
    you can re-generate your rig without losing your previously generated features and your animation data.

Advanced and flexible feature set for character animation
:   The included rig samples (limbs, spines, tails, fingers, faces…) adds to all the stretchy FK/IK features
    a direct deformation secondary layer that lets you flex, bend and deform the character as you like
    through interactive Bendy Bones controls.

Shareable animation through all Rigify rigs
:   Since the control system is generated by Rigify, if you share a meta-rig through different characters
    you will be able to share data between them even if they have different proportions.

Extendable feature set
:   You can save and encode your meta-rigs to a button to have them available at any time
    without recreating it by hand or share your meta-rigs with other people.
    Through Python scripting you can also extend Rigify with new Rigify types or new rig samples
    by implementing your own [feature set](feature_sets.html) package.

Ready to go
:   Once you generate your rig you won’t need Rigify or any other add-on to use it.
user: Show practical ways to work with Mesh Filters in a Blender add-on or script – include code.

assistant: Applies a deformation to all vertices in the mesh at the same time.
Masking, auto-masking and visibility will be taken into account.

To use these operators, click and drag away from left to right
or from right to left for a negative effect.

Smooth
:   Smooths the positions of the vertices to either polish surfaces or remove volume from larger shapes.
    Especially useful to fix most of the artifacts of the voxel remesher.
    This filter works similar to the [Smooth](../brushes/smooth.xhtml) brush.

Surface Smooth
:   Eliminates irregularities of the mesh by making the positions
    of the vertices more uniform while preserving the volume of the object.
    This filter works similar to the *Surface* deformation type of the
    [Smooth](../brushes/smooth.xhtml) brush.

Inflate
:   Displaces vertices uniformly along their normal.
    This filter works similar to the [Inflate](../brushes/inflate.xhtml) brush.

Relax Topology
:   Tries to create an even distribution of quads without deforming the volume of the mesh.
    This filter works the same as holding `Shift` with the
    [Slide Relax](../brushes/slide_relax.xhtml) brush.

Relax Face Sets
:   This will remove the jagged lines visible after drawing or creating a face set.
    This filter works the same as holding `Shift` with the
    [Draw Face Set](../brushes/draw_facesets.xhtml) brush.

Sharpen
:   Sharpens and smooths the mesh based on its curvature,
    resulting in pinching hard edges and polishing flat surfaces.
    Especially useful when sculpting hard surfaces and stylized models
    with creasing and flattening brushes.

Enhance Details
:   Increases the high frequency surface details of the mesh
    by intensifying the difference between creases and valleys.
    This filter works similar to the inverted direction of the
    [Smooth](../brushes/smooth.xhtml) brush.

Erase Multires Displacement
:   Deletes displacement information of
    the [Multires Modifier](../../../modeling/modifiers/generate/multiresolution.xhtml),
    resetting the mesh to a regular subdivision surface result.
    This can be used to reset parts of the sculpt or to fix reprojection artifacts
    after applying a [Shrinkwrap Modifier](../../../modeling/modifiers/deform/shrinkwrap.xhtml).

    Negative strokes will intensify the displacement details,
    this method works similar to *Enhance Details* and can give better results in some circumstances.

Randomize
:   Randomly moves vertices along the vertex normal.
    This filter works similar to the [Randomize Transform](../../../scene_layout/object/editing/transform/randomize.xhtml#bpy-ops-object-randomize-transform).