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

assistant: # ShaderNodeMapRange(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.ShaderNodeMapRange(*ShaderNode*)
:   Remap a value from a range to a target range

    clamp
    :   Clamp the result to the target range [To Min, To Max]

        Type:
        :   boolean, default False

    data_type
    :   - `FLOAT`
          Float – Floating-point value.
        - `FLOAT_VECTOR`
          Vector – 3D vector with floating-point values.

        Type:
        :   enum in [`'FLOAT'`, `'FLOAT_VECTOR'`], default `'FLOAT'`

    interpolation_type
    :   Type:
        :   enum in [Node Map Range Items](bpy_types_enum_items/node_map_range_items.html#rna-enum-node-map-range-items), default `'LINEAR'`

    *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: Give a detailed overview of Brush Settings: syntax, arguments, return values, common patterns.

assistant: Count
:   Number of curves added.

Interpolate – Length
:   Use the average length of the curves in close proximity.

Interpolate – Radius
:   Use the average radius of the curves in close proximity.
    If there is no radius attribute, then the interpolation will skip.

Interpolate – Shape
:   Use the average shape of the curves in close proximity.

Interpolate – Point Count
:   Use the average amount of control points of the curves in close proximity.

Curve Length
:   Length of newly added curves when not interpolated.

Curve Radius
:   Radius of newly added curves when not interpolated.

Points per Curve
:   Number of Control Points for the new created curves when the point count is not interpolated.
user: Explain GPencilInterpolateSettings(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # GPencilInterpolateSettings(bpy_struct)

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

*class* bpy.types.GPencilInterpolateSettings(*bpy_struct*)
:   Settings for Grease Pencil interpolation tools

    interpolation_curve
    :   Custom curve to control ‘sequence’ interpolation between Grease Pencil frames

        Type:
        :   [`CurveMapping`](bpy.types.CurveMapping.html#bpy.types.CurveMapping "bpy.types.CurveMapping"), (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 Grid Divergence Node: syntax, arguments, return values, common patterns.

assistant: # Grid Divergence Node

[image reference removed]

The *Grid Divergence* node computes the **divergence** of a vector field stored
in a voxel grid. Divergence measures how much a field is “spreading out” or
“converging” at each point, representing the net flow entering or leaving a
voxel.

A positive divergence value indicates that the field is expanding outward
from that voxel (acting as a source), while a negative value indicates that the
field is converging inward (acting as a sink). A divergence near zero means
the field is locally balanced, with equal flow in and out.

This operator is commonly used in fluid and smoke simulation workflows, where
it helps enforce incompressibility or visualize the flow behavior of vector
fields such as velocity grids.

Mathematically, for a 3D vector field \(\mathbf{F} = (F_x, F_y, F_z)\),
the divergence is defined as:

\[\nabla \cdot \mathbf{F} =
\frac{\partial F_x}{\partial x} +
\frac{\partial F_y}{\partial y} +
\frac{\partial F_z}{\partial z}\]
user: Describe Using Gizmos from the Blender manual or Python API, including usage steps and snippets.

assistant: Node inputs that can be controlled with a gizmo have an additional icon.
The gizmos of that node are shown if it is selected.
Clicking on the icon pins the gizmo, so that it is shown even if the node is not selected.
Modifying the gizmo in the 3D viewport, modifies the value in the socket.

[image reference removed]

Example of a node group that has gizmos.

Gizmos are often automatically propagated when an input socket with a gizmo is linked.
The gizmo then controls the value that it is propagated to, instead of the input of the node group directly.
Not all nodes support propagating gizmos, but many math operations do.
A double link indicates that the propagation was successful.

[image reference removed]

The gizmo is propagated from the Size X input socket to the Value node.

Gizmos can also be propagated to Group Inputs, in which case they are also available on the parent group node.
If the current group is used by a modifier directly, the gizmo will also be available on the modifier.
Gizmos that are propagated to the modifier always show when the modifier is active, independent of whether any node
is visible or selected.
user: Describe Drawing Tools from the Blender manual or Python API, including usage steps and snippets.

assistant: # Drawing Tools

[image reference removed]

Cursor
:   Change the location of the 3D Cursor.

[Brush](tools/brush.xhtml)
:   Tool to use for any of the [drawing brushes](brushes/draw.xhtml).

[Erase](tools/erase.xhtml#tool-grease-pencil-draw-erase)
:   Erase strokes.

[Fill](tools/fill.xhtml#tool-grease-pencil-draw-fill)
:   Automatic fill closed strokes areas.

[Box](tools/box.xhtml#tool-grease-pencil-draw-box)
:   Draw rectangular shapes.

    [Circle](tools/circle.xhtml#tool-grease-pencil-draw-circle)
    :   Draw oval shapes.

    [Line](tools/line.xhtml#tool-grease-pencil-draw-line)
    :   Draw straight lines.

    [Polyline](tools/polyline.xhtml#tool-grease-pencil-draw-polyline)
    :   Draw straight multiple lines.

    [Arc](tools/arc.xhtml#tool-grease-pencil-draw-arc)
    :   Draw simple arcs.

    [Curve](tools/curve.xhtml#tool-grease-pencil-draw-curve)
    :   Draw complex Bézier style curves.

[Trim](tools/trim.xhtml#tool-grease-pencil-draw-trim)
:   Cut strokes in between others.

[Eyedropper](tools/eyedropper.xhtml#tool-grease-pencil-draw-eyedropper)
:   Eyedropper to create new materials or palette color based on sampled colors in the 3D Viewport.

[Interpolate](tools/interpolate.xhtml#tool-grease-pencil-draw-interpolate) `Ctrl`-`E`
:   Automatically create a breakdown keyframe between two normal keyframes.
user: How do I use Trim Hair Curves in Blender? Include parameters, examples, warnings and best practices.

assistant: # Trim Hair Curves

The *Trim Hair Curves* node shortens or scales hair curves based on a specified length or length factor.
It can be used to precisely control the overall length of hair, create varied or randomized trims,
or adjust groom density and layering.
user: Explain VIEW3D_AST_brush_sculpt_curves(AssetShelf) in complete detail according to the official Blender documentation.

assistant: # VIEW3D_AST_brush_sculpt_curves(AssetShelf)

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

*class* bpy.types.VIEW3D_AST_brush_sculpt_curves(*AssetShelf*)
:   *classmethod* brush_type_poll(*context*, *asset*)

    *static* draw_popup_selector(*layout*, *context*, *brush*, *show_name=True*)

    *static* get_shelf_name_from_context(*context*)

    *classmethod* has_tool_with_brush_type(*context*, *brush_type*)

    *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 Split: syntax, arguments, return values, common patterns.

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: Describe Make Vertex Parent from the Blender manual or Python API, including usage steps and snippets.

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

While in Edit Mode, select another object by either clicking it with `Ctrl`-`LMB` in the
3D Viewport or by selecting it the [Outliner](../../../editors/outliner/introduction.xhtml).
Then, select one or three control points of the surface and press `Ctrl`-`P`.
Parenting an object to three control points will make it follow their averaged position.
user: Provide the full official documentation entry for Export, preserving all code examples.

assistant: ### Scene Options

Object
:   Determine which objects will be included in the export.

    Active:
    :   Export only the active Grease Pencil object.

    Selected:
    :   Export all selected Grease Pencil objects.

    Visible:
    :   Export all visible Grease Pencil object in the scene.

### Export Options

Frame
:   Determine which frames will be included in the export.

    Active:
    :   Export only the active keyframe.

    Selected:
    :   Export all selected keyframes as SVG animation.

    Scene:
    :   Export all frames as SVG animation.

Sampling
:   Precision for the stroke sampling. Low values mean a more accurate result.

Fill
:   When enabled, export the Grease Pencil strokes fill.

Uniform Width
:   When enabled, export strokes with constant thickness.

Clip Camera
:   When enabled and camera view is active, export only the strokes clipped from camera view.
user: How do I use Bmesh in Blender? Include parameters, examples, warnings and best practices.

assistant:  in a valid state or else other tools may behave incorrectly. Any errors that arise from not following these conventions is considered a bug in the script, not a bug in Blender. Selection / Flushing ¶ As mentioned above, it is possible to create an invalid selection state (by selecting a state and then deselecting one of its vertices for example), mostly the best way to solve this is to flush the selection after performing a series of edits. This validates the selection state. Module Functions ¶ Submodules BMesh Operators (bmesh.ops) BMesh Types (bmesh.types) BMesh Utilities (bmesh.utils) BMesh Geometry Utilities (bmesh.geometry) bmesh. from_edit_mesh ( mesh ) ¶ Return a BMesh from this mesh, currently the mesh must already be in editmode. Parameters : mesh ( bpy.types.Mesh ) – The editmode mesh. Returns : the BMesh associated with this mesh. Return type : bmesh.types.BMesh bmesh. new ( * , use_operators = True ) ¶ Parameters : use_operators ( bool ) – Support calling operators in bmesh.ops (uses some extra memory per vert/edge/face). Returns : Return a new, empty BMesh. Return type : bmesh.types.BMesh bmesh. update_edit_mesh ( mesh , * , loop_triangles = True , destructive = True ) ¶ Update the mesh after changes to the BMesh in editmode, optionally recalculating n-gon tessellation. Parameters : mesh ( bpy.types.Mesh ) – The editmode mesh. loop_triangles ( bool ) – Option to recalculate n-gon tessellation. destructive ( bool ) – Use when geometry has been added or removed. Next BMesh Operators (bmesh.ops) Previous Font Drawing (blf) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page BMesh Module (bmesh) Introduction Example Script Standalone Module Mesh Access Edit-Mode Tessellation CustomData Access Keeping a Correct State Selection / Flushing Module Functions from_edit_mesh() new() update_edit_mesh()
user: Describe Relative Paths from the Blender manual or Python API, including usage steps and snippets.

assistant: Many blend-files reference external images or other linked blend-files.
A path tells Blender where to look for these files.
If the external files are moved, the blend-file that references them will not look right.

When you specify one of these external files, the default option is to make the path relative.
Blender stores a partial path evaluated relative to the directory location of the referencing blend-file.
This choice helps when you need to reorganize folders or move your files.

With a relative path, you can move the blend-file to a new location provided
the externally linked files are moved along with it.
For example, you could send someone a folder that contains a blend-file
and a subfolder of external images that it references.

When relative paths are supported, the File Browser provides a *Relative Path* checkbox,
when entering the path into a text field, use a double slash prefix (`//`) to make it so.

Relative paths are the default but this can be changed
in the [File](../../editors/preferences/file_paths.html) tab of the *Preferences*.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Size X
:   Side length of the plane in the X direction.

Size Y
:   Side length of the plane in the Y direction.

Vertices X
:   Number of vertices in the X direction.
    If this is smaller than two, no mesh is generated.

Vertices Y
:   Number of vertices in the Y direction.
    If this is smaller than two, no mesh is generated.
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_shader_diffuse_example.jpg   Lambertian reflection. | <../../../_images/render_shader-nodes_shader_diffuse_behavior.svg>   Diffuse shader behavior. |
| ../../../_images/render_shader-nodes_shader_diffuse_example-oren-nayar.jpg   Oren-Nayar reflection. |  |
user: Provide the full official documentation entry for LimitRotationConstraint(Constraint), preserving all code examples.

assistant: # LimitRotationConstraint(Constraint)

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

*class* bpy.types.LimitRotationConstraint(*Constraint*)
:   Limit the rotation of the constrained object

    euler_order
    :   Explicitly specify the euler rotation order

        - `AUTO`
          Default – Euler using the default rotation order.
        - `XYZ`
          XYZ Euler – Euler using the XYZ rotation order.
        - `XZY`
          XZY Euler – Euler using the XZY rotation order.
        - `YXZ`
          YXZ Euler – Euler using the YXZ rotation order.
        - `YZX`
          YZX Euler – Euler using the YZX rotation order.
        - `ZXY`
          ZXY Euler – Euler using the ZXY rotation order.
        - `ZYX`
          ZYX Euler – Euler using the ZYX rotation order.

        Type:
        :   enum in [`'AUTO'`, `'XYZ'`, `'XZY'`, `'YXZ'`, `'YZX'`, `'ZXY'`, `'ZYX'`], default `'AUTO'`

    max_x
    :   Upper X angle bound

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

    max_y
    :   Upper Y angle bound

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

    max_z
    :   Upper Z angle bound

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

    min_x
    :   Lower X angle bound

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

    min_y
    :   Lower Y angle bound

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

    min_z
    :   Lower Z angle bound

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

    use_legacy_behavior
    :   Use the old semi-broken behavior that does not understand that rotations loop around

        Type:
        :   boolean, default False

    use_limit_x
    :   Use the minimum X value

        Type:
        :   boolean, default False

    use_limit_y
    :   Use the minimum Y value

        Type:
        :   boolean, default False

    use_limit_z
    :   Use the minimum Z value

        Type:
        :   boolean, default False

    use_transform_limit
    :   Transform tools are affected by this constraint as well

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Bpy.Types.Toolsettings, preserving all code examples.

assistant: se_transform_correct_keep_connected ToolSettings.use_transform_data_origin ToolSettings.use_transform_pivot_point_align ToolSettings.use_transform_skip_children ToolSettings.use_uv_custom_region ToolSettings.use_uv_select_island ToolSettings.use_uv_select_sync ToolSettings.uv_sculpt ToolSettings.uv_sculpt_all_islands ToolSettings.uv_sculpt_lock_borders ToolSettings.uv_select_mode ToolSettings.uv_sticky_select_mode ToolSettings.vertex_group_subset ToolSettings.vertex_group_user ToolSettings.vertex_group_weight ToolSettings.vertex_paint ToolSettings.weight_paint ToolSettings.workspace_tool_type ToolSettings.bl_rna_get_subclass() ToolSettings.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Provide the full official documentation entry for GeometryNodePointsToSDFGrid(GeometryNode), preserving all code examples.

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

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

assistant: # ShaderNodeOutputLineStyle(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.ShaderNodeOutputLineStyle(*ShaderNode*)
:   Control the mixing of texture information into the base color of line styles

    blend_type
    :   Type:
        :   enum in [Ramp Blend Items](bpy_types_enum_items/ramp_blend_items.html#rna-enum-ramp-blend-items), default `'MIX'`

    is_active_output
    :   True if this node is used as the active output

        Type:
        :   boolean, default False

    target
    :   Which renderer and viewport shading types to use the shaders for

        - `ALL`
          All – Use shaders for all renderers and viewports, unless there exists a more specific output.
        - `EEVEE`
          EEVEE – Use shaders for EEVEE renderer.
        - `CYCLES`
          Cycles – Use shaders for Cycles renderer.

        Type:
        :   enum in [`'ALL'`, `'EEVEE'`, `'CYCLES'`], default `'ALL'`

    use_alpha
    :   Include alpha of second input in this operation

        Type:
        :   boolean, default False

    use_clamp
    :   Clamp result of the node to 0.0 to 1.0 range

        Type:
        :   boolean, default False

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

assistant: Interpolate strokes between the previous and next keyframe by adding *multiple* keyframes.
When you are on a frame between two keyframes and click the sequence button
a breakdown keyframe will be added on every frame between the previous and next keyframe.

Step
:   The number of frames between generated interpolated frames.

Layer
:   Restrict the interpolation to Active or All layers.

Only Selected Edit Mode
:   When enabled, only selected strokes will be interpolated.

Exclude Breakdowns
:   Exclude existing [Breakdowns keyframes](../../animation/keyframes/introduction.xhtml#keyframe-type) as interpolation extremes.

Flip Mode
:   Invert strokes start and end. Automatic will try to found the right mode for every stroke.

Smooth
:   Amount of smoothing to apply to interpolated strokes for reducing jitter/noise.

Iterations
:   Number of time to smooth newly created strokes.

Type
:   Interpolation method to use for the sequence.
user: Give a detailed overview of Operator Return Items: syntax, arguments, return values, common patterns.

assistant: # Operator Return Items

RUNNING_MODAL:
:   Running Modal.

    Keep the operator running with blender.

CANCELLED:
:   Cancelled.

    The operator exited without doing anything, so no undo entry should be pushed.

FINISHED:
:   Finished.

    The operator exited after completing its action.

PASS_THROUGH:
:   Pass Through.

    Do nothing and pass the event on.

INTERFACE:
:   Interface.

    Handled but not executed (popup menus).
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Points
:   The input points that define the centers of the generated SDF regions.

Radius
:   The radius of influence for each point, defining how far the signed
    distance extends from the point center. Each point is treated as a sphere
    with this radius.

Voxel Size
:   The size of each voxel in object space units.
    Smaller voxel sizes yield higher-resolution fields that better capture
    fine detail, at the cost of increased memory and processing time.
user: Give a detailed overview of Textures: syntax, arguments, return values, common patterns.

assistant: Blender has various built in procedural texture nodes,
with texture coordinates and various parameters as input, and a color or value as output.
No texture data-blocks are needed; instead node groups can be used for reusing texture setups.

For UV mapping and texture painting in the 3D Viewport, the Image Texture node must be used.
When setting such a node as active, it will be displayed in the 3D Viewport
while using [Texture color](../workbench/color.xhtml) mode.
This method can be used to preview painted textures while texture painting.

The default texture coordinates for all nodes are Generated coordinates,
except for Image textures that use UV coordinates by default.
Each node includes some options to modify the texture mapping and resulting color,
and these can be edited in the texture properties.
user: Explain Bevel Node in complete detail according to the official Blender documentation.

assistant: # Bevel Node

Cycles Only

[image reference removed]

The Bevel shader node can be used for rendering rounded corners.
Like bump mapping, this does not modify the actual geometry, only the shading is affected.
Slight rounding on edges helps to capture specular highlights that you would also see in the real world.

Note that this is a very expensive shader, and may slow down renders
by 20% even if there is a lot of other complexity in the scene.
For that reason, we suggest to mainly use this for baking or
still frame renders where render time is not as much of an issue.
The [Bevel Modifier](../../../modeling/modifiers/generate/bevel.xhtml) is a faster option when it works,
but sometimes fails on complex or messy geometry.
user: Provide the full official documentation entry for GeometryNodeInputObject(GeometryNode), preserving all code examples.

assistant: # GeometryNodeInputObject(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.GeometryNodeInputObject(*GeometryNode*)
:   Output a single object

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for General, preserving all code examples.

assistant: |  |  |
| --- | --- |
| `1` - `3` | Switch [Selection mode](../../modeling/meshes/selecting/introduction.xhtml) |
| `4` | Object Mode |
| `5` | [Modes](../../editors/3dview/modes.xhtml) Pie Menu |
| `RMB` | Context menu |
| `Tab` | [Menu Search](../operators.xhtml#bpy-ops-wm-search-menu) |
| `Shift`-`Tab` | Quick access (favorites) |
| `Return` | Rename |
| `Ctrl`-`Return` | Render |
| `Ctrl`-`[` | Toggle Toolbar |
| `Ctrl`-`]` | Toggle Sidebar |
user: Explain Prune Grid Node in complete detail according to the official Blender documentation.

assistant: # Prune Grid Node

[image reference removed]

The *Prune Grid* node optimizes the storage of a voxel grid by collapsing
uniform regions into coarser tiles or inner nodes, reducing memory usage and
improving performance.

This node performs the inverse operation of the
[Voxelize Grid](voxelize_grid.xhtml) node.
While voxelization expands sparse tiles into dense voxels, pruning
detects large uniform areas and replaces them with more compact representations.
This is especially useful after operations that create large
regions of constant values, such as filling, clipping, or thresholding.
user: Show practical ways to work with BlendDataMasks(bpy_struct) in a Blender add-on or script – include code.

assistant: # BlendDataMasks(bpy_struct)

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

*class* bpy.types.BlendDataMasks(*bpy_struct*)
:   Collection of masks

    tag(*value*)
    :   tag

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

    new(*name*)
    :   Add a new mask with a given name to the main database

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – Mask, Name of new mask data-block

        Returns:
        :   New mask data-block

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

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

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

    *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 Options from the Blender manual or Python API, including usage steps and snippets.

assistant: These options are available while the tool is in use, and later in
the [Adjust Last Operation](../../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.

Number of Cuts `Wheel`
:   During the first step, you can change the number of cuts to create by
    scrolling `Wheel`, typing a number, or pressing `PageUp`/`PageDown`.

    |  |  |
    | --- | --- |
    | ../../../../_images/modeling_meshes_editing_edge_loopcut-slide_multicut.png   Preview of multiple edge loops. | ../../../../_images/modeling_meshes_editing_edge_loopcut-slide_multicut-after.png   Result of using multiple cuts. |

Smoothness
:   How much to offset the newly created edges along their normals to maintain surface curvature.
    You can change this in the first step using `Alt`-`Wheel`, but because the smoothness
    isn’t previewed at that stage, it’s typically better to change it afterwards in the
    *Adjust Last Operation* panel.

    |  |  |
    | --- | --- |
    | ../../../../_images/modeling_meshes_editing_edge_loopcut-slide_unsmooth.png   Added edge loop without smoothing. | ../../../../_images/modeling_meshes_editing_edge_loopcut-slide_smooth.png   Same edge loop, but with smoothing value. |

Falloff
:   Falloff type for *Smoothness*. Changes the shape of the profile.

Factor
:   Position of the edge loop relative to the surrounding ones.

Even `E`
:   Makes the new edge loop have an even distance to an existing adjacent one
    (instead of a distance that’s proportional to the length of each
    perpendicular edge it crosses). You can press `E` during the second
    step to toggle it.

Flipped `F`
:   Keep an *Even* distance to the other adjacent edge. You can press `F`
    during the second step to toggle it.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_loopcut-slide_uneven.png   Cut with *Even* disabled. | ../../../../_images/modeling_meshes_editing_edge_loopcut-slide_even.png   Cut with *Even* enabled. The red dot shows the side to which an even distance is kept. | ../../../../_images/modeling_meshes_editing_edge_loopcut-slide_even_flipped.png   Cut with *Even* and *Flipped* enabled. |

Clamp `C`
:   When unchecked, the new edge loop can go outside the face loop’s boundary edges.
    You can press `C` or hold `Alt` during the second step to toggle it.

Mirror Editing
:   When checked, sliding the newly created edges will also slide any existing edges
    on the other side of the mesh. [Mesh Symmetry](../../tools/tool_settings.xhtml#modeling-meshes-tools-settings-mirror)
    needs to be enabled for this to work.

Correct UVs
:   When unchecked, the faces in the [UV map](../../../../editors/uv/introduction.xhtml) will be split
    uniformly even if the cut was placed off-center on the 3D mesh.
user: How do I use Transform in Blender? Include parameters, examples, warnings and best practices.

assistant: You can move the selected node(s) by clicking and dragging any empty part of them.
Alternatively, press `G`, move the mouse, and click `LMB` to confirm.

Dragging a node on top of an existing link will intelligently insert the selected node into the link path.
This generally uses the first socket that matches the link type.
The automatic node attachment feature can be toggled with `Alt`.
When a node is automatically attached, the surrounding nodes
will be offset to the right or left depending on the `T` toggle;
see [Auto-Offset](arranging.xhtml#editors-nodes-usage-auto-offset) for more information.

While dragging nodes, you can press `F` to toggle their parent [Frame](types/layout/frame.xhtml):

- If the nodes are inside a frame, they will be detached from it.
- If the nodes are not inside a frame and there is a frame under the cursor, they will be attached to that frame.

In general, it is recommended to arrange your nodes so that data flows from left to right, top to bottom.

The width of a node can be changed by dragging its left or right border.

Rotating (`R`) and scaling (`S`) only apply when multiple nodes are selected,
and only affect their positions.
user: What is AnimDataDrivers(bpy_struct) and how is it used in Blender Python scripting?

assistant: # AnimDataDrivers(bpy_struct)

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

*class* bpy.types.AnimDataDrivers(*bpy_struct*)
:   Collection of Driver F-Curves

    new(*data_path*, *\**, *index=0*)
    :   new

        Parameters:
        :   - **data_path** (*string**,* *(**never None**)*) – Data Path, F-Curve data path to use
            - **index** (*int in* *[**0**,* *inf**]**,* *(**optional**)*) – Index, Array index

        Returns:
        :   Newly Driver F-Curve

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

    remove(*driver*)
    :   remove

    from_existing(*\**, *src_driver=None*)
    :   Add a new driver given an existing one

        Parameters:
        :   **src_driver** ([`FCurve`](bpy.types.FCurve.html#bpy.types.FCurve "bpy.types.FCurve"), (optional)) – Existing Driver F-Curve to use as template for a new one

        Returns:
        :   New Driver F-Curve

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

    find(*data_path*, *\**, *index=0*)
    :   Find a driver F-Curve. Note that this function performs a linear scan of all driver F-Curves.

        Parameters:
        :   - **data_path** (*string**,* *(**never None**)*) – Data Path, F-Curve data path
            - **index** (*int in* *[**0**,* *inf**]**,* *(**optional**)*) – Index, Array index

        Returns:
        :   The found F-Curve, or None if it doesn’t exist

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

    *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 Import Curve Operators from the Blender manual or Python API, including usage steps and snippets.

assistant: # Import Curve Operators

bpy.ops.import_curve.svg(*\**, *filepath=''*, *filter_glob='\*.svg'*, *directory=''*, *files=None*)
:   Load a SVG file

    Parameters:
    :   - **filepath** (*string**,* *(**optional**,* *never None**)*) – File Path, Filepath used for importing the file
        - **filter_glob** (*string**,* *(**optional**,* *never None**)*) – filter_glob
        - **directory** (*string**,* *(**optional**,* *never None**)*) – directory
        - **files** (`bpy_prop_collection` of `OperatorFileListElement`, (optional)) – File Path

    File:
    :   [addons_core/io_curve_svg/__init__.py:61](https://projects.blender.org/blender/blender/src/branch/main/scripts/addons_core/io_curve_svg/__init__.py#L61)
user: Show practical ways to work with GeometryNodeCurveEndpointSelection(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeCurveEndpointSelection(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.GeometryNodeCurveEndpointSelection(*GeometryNode*)
:   Provide a selection for an arbitrary number of endpoints in each spline

    *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 Properties in complete detail according to the official Blender documentation.

assistant: # Properties

Most bones’ properties (except the transform ones) are regrouped in each bone’s panels,
in the *Bones* tab in *Edit Mode*. Let us detail them.

Note that some of them are also available in the 3D Viewport,
through the three pop-up menus within the same entry:

- *Toggle Setting*: `Shift`-`W` or Armature ‣ Bone Settings ‣ Toggle a Setting
- *Enable Setting*: `Shift`-`Ctrl`-`W` or Armature ‣ Bone Settings ‣ Enable a Setting
- *Disable Setting*: `Alt`-`W` or Armature ‣ Bone Settings ‣ Disable a Setting

Display Wire
:   Always display the bone as wireframe.

Deform
:   (also `Shift`-`W` ‣ (Deform, …)).

Multiply Vertex Group by Envelope
:   (also `Shift`-`W` ‣ (Multiply Vertex Group by Envelope, …)).

    These settings control how the bone influences its geometry, along with the bones’ joints radius.
    This will be detailed in the [skinning part](../../skinning/index.html).

Inherit Rotation
:   The bone automatically rotates together with its parent in *Pose Mode*. For more details,
    see the [relations page](../properties/relations.html#bpy-types-editbone-parent).

Lock
:   (also `Shift`-`W` ‣ (Locked, …))
    This will prevent all editing of the bone in *Edit Mode*;
    see [bone locking](introduction.html#animation-armatures-bones-locking).
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_shader_emission_example.jpg   Emission shader, with strength at 1.0. | ../../../_images/render_shader-nodes_shader_emission_example-bright.jpg   Emission shader, with strength at 3.0. |
user: Describe Transforming from the Blender manual or Python API, including usage steps and snippets.

assistant: # Transforming

Transform tools to [move, rotate and scale](../tools/transforms.xhtml)
are also available in Sculpt Mode,
but with an important difference to other modes. Sculpt Mode uses its own pivot point,
which can be manually positioned `Shift`-`RMB`
or automatically positioned with [Mask Expand](../editing/expand.xhtml#bpy-ops-sculpt-mask-expand).
This ensures that the pivot point can be more freely placed and always moves with the transformed geometry.

Optionally instead of keeping the transform tools active, you can enable the
[viewport gizmos](../../../editors/3dview/display/gizmo.xhtml) to have access to the gizmo at all times.

Apart from the transform tools there are also special brushes to move,
rotate and scale the topology like [Pose](../brushes/pose.xhtml),
[Boundary](../brushes/boundary.xhtml)
and [Elastic Deform](../brushes/elastic_deform.xhtml).