PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use ThemeInfo(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ThemeInfo(bpy_struct)

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

*class* bpy.types.ThemeInfo(*bpy_struct*)
:   Theme settings for Info

    info_debug
    :   Background color of Debug icon

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

    info_debug_text
    :   Foreground color of Debug icon

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    info_error_text
    :   Foreground color of Error icon

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    info_info_text
    :   Foreground color of Info icon

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    info_operator
    :   Background color of Operator icon

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

    info_operator_text
    :   Foreground color of Operator icon

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    info_property
    :   Background color of Property icon

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

    info_property_text
    :   Foreground color of Property icon

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    info_selected
    :   Background color of selected line

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    info_selected_text
    :   Text color of selected line

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    info_warning_text
    :   Foreground color of Warning icon

        Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    space
    :   Settings for space

        Type:
        :   [`ThemeSpaceGeneric`](bpy.types.ThemeSpaceGeneric.html#bpy.types.ThemeSpaceGeneric "bpy.types.ThemeSpaceGeneric"), (readonly, never None)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Noise

The *Noise* modifier uses a pseudo-random number generator to variably distribute the property along the stroke.

Amplitude
:   The maximum value of the noise. A higher amplitude means a less transparent (more solid) stroke.

Period
:   The period of the noise. This means how quickly the property value can change.
    A higher value means a more smoothly changing color along the stroke.

Seed
:   Seed used by the pseudo-random number generator.

Asymmetric Thickness only
:   Allows the thickness to be distributed unevenly at every point.
    Internally, the stroke is represented as a backbone with a thickness to the right and left side.
    All other thickness shaders make sure that the left and right thickness values are equal.
    For the Noise shader however, a meaningful (and good-looking) result
    can be created by assigning different values to either side of the backbone.

[image reference removed]

Effect generated with a noise thickness modifier using asymmetric thickness.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Geometry
:   The geometry to retrieve the attribute from.

Value
:   A field to evaluate on the source *Geometry*. The values are then retrieved from specific
    indices for the output.

Index
:   Which index to use when retrieving the data from the input *Value* field. Any index can be
    connected, resulting in a “shuffling” of the values.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy.context.meta_ball`](bpy.context.html#bpy.context.meta_ball "bpy.context.meta_ball") - [`BlendData.metaballs`](bpy.types.BlendData.html#bpy.types.BlendData.metaballs "bpy.types.BlendData.metaballs") | - [`BlendDataMetaBalls.new`](bpy.types.BlendDataMetaBalls.html#bpy.types.BlendDataMetaBalls.new "bpy.types.BlendDataMetaBalls.new") - [`BlendDataMetaBalls.remove`](bpy.types.BlendDataMetaBalls.html#bpy.types.BlendDataMetaBalls.remove "bpy.types.BlendDataMetaBalls.remove") |
user: What is FunctionNodeFindInString(FunctionNode) and how is it used in Blender Python scripting?

assistant: # FunctionNodeFindInString(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.FunctionNodeFindInString(*FunctionNode*)
:   Find the number of times a given string occurs in another string and the position of the first match

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

assistant: [image reference removed]

Shortest Edge Paths on a deformed Ico Sphere.

[image reference removed]

Gradient-colored maze showing shortest paths to a target sphere.

[image reference removed]

Organic branching structure on Suzanne.
user: Describe Interpolate Hair Curves from the Blender manual or Python API, including usage steps and snippets.

assistant: # Interpolate Hair Curves

The *Interpolate Hair Curves* node generates new hair curves by interpolating existing *guide* curves
on a surface mesh.
It allows for efficient grooming workflows where a small number of guide curves define the overall
shape, and the node fills in additional interpolated curves to create a dense, detailed hair system.

For simpler duplication-based setups, the
[Duplicate Hair Curves](duplicate_hair_curves.html)
node provides a lighter-weight alternative that may perform faster.
user: Give a detailed overview of Disconnecting Sockets: syntax, arguments, return values, common patterns.

assistant: ### Interactively

Drag the link away from its input socket and let it go, keeping it unconnected.

### Mute Links

Activate the menu item or hold the key combination,
then draw a line across one or more links to mute/unmute them.
A muted link acts as though it’s no longer there; this also means the input fields
for specifying fixed values become visible again.

When muting links on the input side of a [reroute node](types/layout/reroute.html),
the links on its output side will be muted too.

[image reference removed]

### Cut Links

Activate the menu item or hold the key combination,
then draw a line across one or more links to delete them.

Detach Links `Alt`-`LMB` drag
:   Use Detach Links to cut all the links attached to the selected nodes
    and move the nodes to a new location.
user: Provide the full official documentation entry for Animating Stabilization Parameters, preserving all code examples.

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

assistant: # GeometryNodeSetMaterialIndex(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.GeometryNodeSetMaterialIndex(*GeometryNode*)
:   Set the material index for each selected geometry element

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

assistant: - Converting the string `"3.1415"` with *Float* selected outputs a value of `3.1415` and a length of `6`.
- Converting `"42abc"` with *Integer* selected outputs `42` and a length of `2`.
- Converting an invalid string such as `"hello"` outputs `0` and a length of `0`.
user: Show practical ways to work with Node Compare Operation Items in a Blender add-on or script – include code.

assistant: # Node Compare Operation Items

LESS_THAN:
:   Less Than.

    True when the first input is smaller than second input.

LESS_EQUAL:
:   Less Than or Equal.

    True when the first input is smaller than the second input or equal.

GREATER_THAN:
:   Greater Than.

    True when the first input is greater than the second input.

GREATER_EQUAL:
:   Greater Than or Equal.

    True when the first input is greater than the second input or equal.

EQUAL:
:   Equal.

    True when both inputs are approximately equal.

NOT_EQUAL:
:   Not Equal.

    True when both inputs are not approximately equal.

BRIGHTER:
:   Brighter.

    True when the first input is brighter.

DARKER:
:   Darker.

    True when the first input is darker.
user: Describe Evaluate on Domain Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Evaluate on Domain Node

[image reference removed]

The *Evaluate on Domain* allows evaluating a field for a different [attribute domain](../../attributes_reference.xhtml#attribute-domains)
than the domain from the [field context](../../fields.xhtml#field-context). For example, the face index could be used instead
of the face corner index, when setting the values of a [UV Map](../../../../glossary/index.xhtml#term-UV-Map)
user: Describe Viewport Display from the Blender manual or Python API, including usage steps and snippets.

assistant: These settings control the curve rendering settings used when the 3D viewport is set to
[Material Preview](../../../editors/3dview/display/shading.xhtml#dview-material-preview)

Shape
:   Strand:
    :   Render curves as a thin strand roughly a pixel wide.
        Curve diameter parameters are ignored with this setting.

    Strip:
    :   Render curves as a flat ribbon with rounded normals.

Additional Subdivisions
:   Additional subdivisions to be applied on top of the curve resolution set in the
    hair system settings. Increasing this value will smooth out the curves of the strands.
user: Describe Redistribute Curve Points from the Blender manual or Python API, including usage steps and snippets.

assistant: # Redistribute Curve Points

The *Redistribute Curve Points* node repositions existing control points so they are
evenly spaced along each curve.
This helps improve uniformity, especially after deformations or procedural
operations that distort point spacing, ensuring consistent interpolation and smoother results.
user: What is Introduction and how is it used in Blender Python scripting?

assistant: # Introduction

Modifiers are automatic operations that affect an object’s geometry in a non-destructive way.
With modifiers, you can perform many effects automatically that would otherwise be too tedious to do manually
(such as subdivision surfaces) and without affecting the base geometry of your object.

They work by changing how an object is displayed and rendered, but not the geometry which you can edit directly.
You can add several modifiers to a single object to form [The Modifier Stack](#the-modifier-stack)
and *Apply* a modifier if you wish to make its changes permanent.

They can be added to the active object using the [Add Modifier](../../scene_layout/object/editing/modifiers.html#bpy-ops-object-modifier-add) operator,
the “Add Modifier” button at the top of Modifiers tab in the [Properties Editor](../../editors/properties_editor.html),
or using `Shift`-`A` in the same tab.
New modifiers are always added at the bottom of the [stack](#modifier-stack) (i.e. will be applied last).

There are many built-in modifiers but Blender also allows users
to make their own modifiers through [Geometry Nodes](../geometry_nodes/index.html).
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.armature`](bpy.context.html#bpy.context.armature "bpy.context.armature") - [`BlendData.armatures`](bpy.types.BlendData.html#bpy.types.BlendData.armatures "bpy.types.BlendData.armatures") | - [`BlendDataArmatures.new`](bpy.types.BlendDataArmatures.html#bpy.types.BlendDataArmatures.new "bpy.types.BlendDataArmatures.new") - [`BlendDataArmatures.remove`](bpy.types.BlendDataArmatures.html#bpy.types.BlendDataArmatures.remove "bpy.types.BlendDataArmatures.remove") |
user: Provide the full official documentation entry for Volume to Mesh Modifier, preserving all code examples.

assistant: # Volume to Mesh Modifier

This modifier is the inverse of the *Mesh to Volume* modifier.
It takes an existing volume object and converts one of its grids to a mesh.
Only scalar grids (such as the density grid) can be converted.
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: ### Using Image Output

This can simply be achieved by using the Alpha Over node.

[image reference removed]

Image output.

### Using Plane Output

This can be achieved by mixing the movie clip and the image by using the plane output as the factor.

[image reference removed]

Plane output.
user: Describe Snap Base from the Blender manual or Python API, including usage steps and snippets.

assistant: Determines which point in the geometry is the snap base that will snap to the target.

Active:
:   Snaps using the origin (in Object Mode) or center (in Edit Mode) of the active element.

Median:
:   Snaps using the median of the selection.

Center:
:   Snaps using the current transformation center
    (another word for the [pivot point](pivot_point/index.xhtml)).
    This option is especially useful in combination with the
    [3D Cursor](../3d_cursor.xhtml) for choosing the snapping
    point completely manually.

Closest:
:   Snaps using the vertex that’s closest to the target.

|  |  |  |
| --- | --- | --- |
| ../../../_images/editors_3dview_controls_snapping_target-closest.png   Closest. | ../../../_images/editors_3dview_controls_snapping_target-active.png   Active. | ../../../_images/editors_3dview_controls_snapping_target-median.png   Median. |
user: Give a detailed overview of Frame Sequence Workflow: syntax, arguments, return values, common patterns.

assistant: 1. First prepare your animation.
2. In the *Format* panel, choose the render size, Pixel Aspect Ratio, and the Range of Frames to use,
   as well as the frame rate, which should already be set.
3. In the Output panel set up your animation to be rendered out as images,
   generally using a format that does not compromise any quality.
4. Choose the output path and file type in the Output panel as well, for example `//render/my-anim-`.
5. Confirm the range of your animation (frame Start and End).
6. Save your blend-file.
7. Press the *Animation* button and once the animation is finished,
   use your file manager to navigate to the output folder (`render` in this example).
   You will see lots of images that have a sequence number attached to. These are the single frames.
8. In Blender, open the [Video Sequencer](../../video_editing/index.xhtml).
9. Choose *Add Image* from the add menu. Select all the frames from your output folder that you want to include
   in your animation. They will be added as a strip in the Sequence editor.
10. Now you can edit the strip and add effects or leave it like it is.
    You can add other strips, like an audio strip.
11. Scrub through the animation to check if you have included all the frames.
12. In the Output panel, choose the container and codec you want (e.g. `MPEG H.264`) and configure them.
    The video codecs are described in [Output Options](properties/output.xhtml).
13. Click the *Animation* render button and Blender will render out the Sequence editor output into a movie.
user: Give a detailed overview of MovieTrackingPlaneTrack(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # MovieTrackingPlaneTrack(bpy_struct)

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

*class* bpy.types.MovieTrackingPlaneTrack(*bpy_struct*)
:   Match-moving plane track data for tracking

    image
    :   Image displayed in the track during editing in clip editor

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

    image_opacity
    :   Opacity of the image

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

    markers
    :   Collection of markers in track

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

    name
    :   Unique name of track

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

    select
    :   Plane track is selected

        Type:
        :   boolean, default False

    use_auto_keying
    :   Automatic keyframe insertion when moving plane corners

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

assistant: # Film

Exposure
:   This can be used to change the brightness of an image.
    Different than the *Exposure* option found in the [Color management](../../color_management/displays_views.xhtml#render-post-color-management) panel,
    this exposure option works *on the data* while the Color management exposure is on the *view transform*.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeForeachGeometryElementOutput.main_items`](bpy.types.GeometryNodeForeachGeometryElementOutput.html#bpy.types.GeometryNodeForeachGeometryElementOutput.main_items "bpy.types.GeometryNodeForeachGeometryElementOutput.main_items") |  |
user: What is Introduction and how is it used in Blender Python scripting?

assistant: # Introduction

We have seen in [previous pages](../index.xhtml) how to design an armature,
create chains of bones, etc.
Now, having a good rig is not the final goal, unless you want to produce a “Dance Macabre” animation,
you will likely want to put some flesh on your skeletons!
Surprisingly, “linking” an armature to the object(s)
it should transform and/or deform is called the “skinning” process…

[image reference removed]

The human mesh skinned on its armature.

In Blender, you have two main skinning types:

1. You can [Parent/Constrain Objects to Bones](../../../scene_layout/object/editing/parent.xhtml) –
   then, when you transform the bones in *Pose Mode*, their “children” objects are also transformed,
   exactly as with a standard parent/children relationship…
   The “children” are **never** deformed when using this method.
2. You can [Use the Armature Modifier on entire Mesh](parenting.xhtml),
   and then, some parts of this object to some bones inside this armature.
   This is the more complex and powerful method,
   and the only way to really deform the geometry of the object,
   i.e. to modify its vertices/control points relative positions.
user: Show practical ways to work with View3D Context in a Blender add-on or script – include code.

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

bpy.context.selected_ids
:   Type:
    :   sequence of [`bpy.types.ID`](bpy.types.ID.html#bpy.types.ID "bpy.types.ID")
user: Provide the full official documentation entry for Controls, preserving all code examples.

assistant: Move `Spacebar`
:   Changes the location of the line.

Snap `Ctrl`
:   Constrains the rotation of the line to 15 degree intervals.

Flip `F`
:   Changes the side of the line that is the inner/outer side;
    this option is useful when using *Clear Inner*, *Clear Outer* and/or *Fill*.
user: Explain Sampling in complete detail according to the official Blender documentation.

assistant: # Sampling

Sampling is the process of tracing rays from the camera into the scene and
bouncing them around until they reach a light source such as a Light object,
an emissive mesh, or the world background. The algorithm for this is known
as the integrator.

Viewport (Max) Samples
:   The number of paths to trace per pixel in the 3D Viewport
    (when using the *Rendered* [shading mode](../../../editors/3dview/display/shading.html)).
    Setting this value to zero enables indefinite sampling.

Render (Max) Samples
:   The number of paths to trace per pixel in the final render.
    A higher number results in a cleaner image at the cost of a longer render time.

Time Limit
:   Stops rendering if the time exceeds the limit, even if the desired sample count
    hasn’t been reached yet. Setting this value to zero disables the limit.
user: How do I use Inverse Kinematics Constraint in Blender? Include parameters, examples, warnings and best practices.

assistant: # Inverse Kinematics Constraint

The *Inverse Kinematics* constraint makes not just one bone, but a whole chain
of bones rotate to follow a target. A common example is automatically rotating
the bones in a character’s arm to achieve a desired hand position.
See [Inverse Kinematics](../../armatures/posing/bone_constraints/inverse_kinematics/introduction.html) for details.

The constraint can be added quickly using the shortcut `Shift`-`I`.
See [Add IK to Bone](../../armatures/posing/editing/inverse_kinematics.html#bpy-ops-pose-ik-add).
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

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

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

Axis
:   Defines the axis around which each curve is rotated.
    By default, the tangent direction at the root of each curve is used.

Angle
:   Specifies the amount of rotation applied around the chosen axis, in radians.
    Positive values rotate in one direction, negative values in the opposite.

Random Offset
:   Adds a random offset to the rotation angle for each curve, introducing natural variation
    and avoiding a uniform appearance.

Lock Ends
:   When enabled, constrains the deformation to preserve the relative position between
    the root and tip of each curve.
    This helps maintain the overall direction and placement of the hair strands.

Seed
:   Sets the random seed used for generating the random offsets.
    Changing this value produces different randomized rotation patterns while keeping the same parameters.
user: Describe Select Linked from the Blender manual or Python API, including usage steps and snippets.

assistant: Selects all the bones in the chain which the active (last selected) bone belongs to.

All Forks
:   Selects all bones connected to the active bone even if the branch off from the current bone.

Linked bones selection.

|  |  |
| --- | --- |
| ../../../_images/animation_armatures_bones_selecting_single-bone.png   A single selected bone. | ../../../_images/animation_armatures_bones_selecting_whole-chain.png   Its whole chain selected with Linked. |
user: Describe CollectionExports(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CollectionExports(bpy_struct)

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

*class* bpy.types.CollectionExports(*bpy_struct*)
:   Collection of export handlers

    new(*type*, *\**, *name=''*)
    :   Add an export handler to the collection

        Parameters:
        :   - **type** (enum in [`'IO_FH_alembic'`, `'IO_FH_usd'`, `'IO_FH_obj'`, `'IO_FH_ply'`, `'IO_FH_stl'`, `'IO_FH_fbx'`, `'IO_FH_gltf2'`]) – Type, The type of export handler to add
            - **name** (*string**,* *(**optional**,* *never None**)*) – Name, Name of the new export handler

        Returns:
        :   Newly created export handler

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

    remove(*exporter*)
    :   Remove an export handler from the collection

        Parameters:
        :   **exporter** ([`CollectionExport`](bpy.types.CollectionExport.html#bpy.types.CollectionExport "bpy.types.CollectionExport")) – Export Handler to remove

    move(*from_index*, *to_index*)
    :   Move an export handler

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

    *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 In Object Mode, preserving all code examples.

assistant: Each object gets transformed around its [origin](../../../../scene_layout/object/origin.html),
which is a point that can be chosen freely and doesn’t have to be in the center.
In the example below, the orange rectangle has it in a corner instead.

[image reference removed]

Rotation around individual origins.

The images below compare Individual Origins to [Median Point](median_point.html).

[image reference removed]

Starting situation, rotation around Individual Origins, rotation around Median Point.

[image reference removed]

Starting situation, scaling using Individual Origins, scaling using Median Point.
user: How do I use Tool Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: Steps
:   Specifies how many copies will be extruded along the “sweep”.

Use Duplicates
:   When enabled, will keep the original selected elements as separated islands in the mesh
    (i.e. unlinked to the result of the spin extrusion).

Axis
:   Specifies the axis to use as the pivot of the spin operation.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Collection
:   Collection to get the properties from.

Separate Children
:   Output each child of the collection as a separate instance. The list of instances will be sorted
    alphabetically with the objects and child collections sorted together. This can be used with
    the *Pick Instance* option in the [Instance on Points Node](../../instances/instance_on_points.xhtml) to
    choose between collection children at each point.

Reset Children
:   Remove the transform of each of the collection’s children when converting them to instances.
    This is useful in order to keep child objects visually separate in the viewport,
    while keeping every instance located directly at the location of the point it was added for.
user: How do I use Installing Python in Blender? Include parameters, examples, warnings and best practices.

assistant: 1. Download the [Python installation package](https://www.python.org/downloads/) for Windows. In this guide version
   3.9.x is used.
2. Install Python with the installation wizard. Please make sure that you enable the “Add Python to PATH” option:

   [image reference removed]

   The option must be enabled so you can build the manual with the make script.

   All other settings can remain as set by default.
user: Show practical ways to work with Duplicate in a Blender add-on or script – include code.

assistant: Duplicate a strip to make an unlinked copy;
drag it to a time and channel, and drop it by `LMB` click.

For strips that reference an ID, for example scene strips, this will
duplicate the scene and use this new scene in the duplicated strip.
user: Provide the full official documentation entry for Attributes, preserving all code examples.

assistant: The *Attributes* panel contains different hair characteristics such as the position and color of hair strands.

Use the [List View](../../interface/controls/templates/list_view.xhtml#ui-list-view) to manage attributes.
user: Provide the full official documentation entry for GeometryNodeAttributeDomainSize(GeometryNode), preserving all code examples.

assistant: # GeometryNodeAttributeDomainSize(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.GeometryNodeAttributeDomainSize(*GeometryNode*)
:   Retrieve the number of elements in a geometry for each attribute domain

    component
    :   Type:
        :   enum in [Geometry Component Type Items](bpy_types_enum_items/geometry_component_type_items.html#rna-enum-geometry-component-type-items), default `'MESH'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Operation
:   Operation to use against the input mask.

    Add:
    :   This yields the *union* of the input mask and the generated mask:
        Areas covered by the generated mask are set to the specified *Value*.
        Other parts of the input masked are passed through unchanged, or set to black if there is no input mask.

    Subtract:
    :   Values of the input mask have the specified *Value* subtracted from them.

    Multiply:
    :   This yields the *intersection* of this generated mask and the input mask:
        Values of the input mask are multiplied by the specified *Value* for the area covered by the generated mask.
        All other areas become black.

    Not:
    :   Any area covered by both the input mask and the generated mask becomes black.
        Areas covered by the generated mask that are black on the input mask become the specified *Value*.
        Areas uncovered by the generated mask remain unchanged.

Mask
:   An optional mask to use as the base for mask operations.

Value
:   Intensity of the generated mask.

Position
:   Position of the center of the ellipse as a fraction of the total width or height.
    (0.5, 0.5 creates a centered ellipse; 0.0, 0.0 creates an ellipse with its center in the lower left.)

Size
:   Width/Height of the ellipse as a fraction of the total image *width*, not height.
    Equal *Width* and *Height* values with produce a circle.

Rotation
:   Rotation of the ellipse around its center point.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Object
:   Object to get the properties from.

As Instance
:   Output the entire object as single instance instead of realized geometry.
    This allows instancing non-geometry object types, because the output will contain an instance of the object.
user: Provide the full official documentation entry for Library Overrides, preserving all code examples.

assistant: # Library Overrides

Library Overrides is a system designed to allow editing
[linked data](link_append.html), while keeping it in sync
with the original library data. Most types of linked data-blocks can be overridden,
and the properties of these overrides can then be edited. When the library data changes,
unmodified properties of the overridden one will be updated accordingly.

Library overrides supports:

- Multiple independent overrides of a same linked data
  (e.g. having the same character multiple times in the same scene).
- Adding new modifiers and constraints, anywhere in the stack.
- Recursively chaining overrides (i.e. link and override overrides from another library file, etc.).
user: Describe Editing UVs from the Blender manual or Python API, including usage steps and snippets.

assistant: # Editing UVs

After unwrap, you will likely need to arrange the UV maps,
so that they can be used in texturing or painting. Your goals for editing are:

- Stitch pieces (of UV maps) back together.
- Minimize wasted space in the image.
- Enlarge the faces where you want more detail.
- Re-size/enlarge the faces that are stretched.
- Shrink the faces that are too grainy and have too much detail.

With a minimum of dead space,
the most pixels can be dedicated to giving the maximum detail and fineness to the UV texture.
A UV face can be as small as a pixel (the little dots that make up an image)
or as large as an entire image. You probably want to make major adjustments first,
and then tweak the layout.
user: Give a detailed overview of Node Groups: syntax, arguments, return values, common patterns.

assistant: # Node Groups

[image reference removed]

Example of a node group.

Grouping nodes can simplify a node tree by hiding complexity and reusing common functionality.
A node group is visually identified by its green title bar.

Conceptually, node groups allow you to treat a *set* of nodes as a single unit.
They are similar to functions in programming: reusable, composable, and parametrizable.

For example, suppose you create a “Wood” material and want to use it in multiple colors.
You could duplicate the entire node setup for each color, but maintaining those duplicates
would be tedious if you later decide to change the wood grain detail.
Instead, you can move the nodes that generate the wood pattern into a node group.
Each material can then reuse this group and supply a custom color as input.
Any updates to the grain detail need to be made only once—inside the node group.

Node groups can be nested; that is, a group can contain other groups.

*Group Input* and *Group Output* nodes are used to represent data flowing into and out of the group.

The *Group Input* node provides access to the group’s input sockets from within the node group.
These sockets act as parameters that control the behavior of the group from the outside.
You can connect them to internal nodes to drive values such as factors, colors, or geometry inputs.

The *Group Output* node defines the data that is passed out of the node group.
Only sockets connected to this node will be available as outputs on the group itself.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: The node can contain an arbitrary number of input sockets.
Each socket can be given a custom name and type. Supported types include (but not limited to):

- Geometry
- Objects
- Values (e.g. float, integer, boolean, vector, color)
- Fields
- Nested Bundles
user: How do I use GeometryNodeGridVoxelize(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeGridVoxelize(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.GeometryNodeGridVoxelize(*GeometryNode*)
:   Remove sparseness from a volume grid by making the active tiles into voxels

    data_type
    :   Node socket data type

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # MovieTrackingReconstruction(bpy_struct)

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

*class* bpy.types.MovieTrackingReconstruction(*bpy_struct*)
:   Match-moving reconstruction data from tracker

    average_error
    :   Average error of reconstruction

        Type:
        :   float in [-inf, inf], default 0.0, (readonly)

    cameras
    :   Collection of solved cameras

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

    is_valid
    :   Whether the tracking data contains valid reconstruction information

        Type:
        :   boolean, default False, (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: How do I use GeometryNodeSampleUVSurface(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeSampleUVSurface(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.GeometryNodeSampleUVSurface(*GeometryNode*)
:   Calculate the interpolated values of a mesh attribute at a UV coordinate

    data_type
    :   Type:
        :   enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items), default `'FLOAT'`

    *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