PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Auto-Name from the Blender manual or Python API, including usage steps and snippets.

assistant: The three *AutoName* entries of the Armature ‣ Names menu allow you to
automatically add a suffix to all selected bones, based on the position of their root
relative to the armature’s origin and its local coordinates:

AutoName Left/Right
:   Will add the “.L” suffix to all bones with a *positive* X coordinate root,
    and the “.R” suffix to all bones with a *negative* X coordinate root.
    If the root is exactly at 0.0 on the X axis, the X coordinate of the tip is used.
    If both joints are at 0.0 on the X axis, the bone will just get a period suffix, with no “L”/ “R”
    (as Blender cannot decide whether it is a left or right bone…).

AutoName Front/Back
:   Will add the “.Bk” suffix to all bones with a *positive* Y coordinate root,
    and the “.Fr” suffix to all bones with a *negative* Y coordinate root.
    The same as with *AutoName Left-Right* goes for 0.0 Y coordinate bones…

AutoName Top/Bottom
:   Will add the “.Top” suffix to all bones with a *positive* Z coordinate root,
    and the “.Bot” suffix to all bones with a *negative* Z coordinate root.
    The same as with *AutoName Left-Right* goes for 0.0 Z coordinate bones…
user: Give a detailed overview of GeometryNodeInputVoxelIndex(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeInputVoxelIndex(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.GeometryNodeInputVoxelIndex(*GeometryNode*)
:   Retrieve the integer coordinates of the voxel that the field is evaluated on

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

assistant: |  |  |
| --- | --- |
| - [`Action.layers`](bpy.types.Action.html#bpy.types.Action.layers "bpy.types.Action.layers") - [`ActionLayers.new`](bpy.types.ActionLayers.html#bpy.types.ActionLayers.new "bpy.types.ActionLayers.new") | - [`ActionLayers.remove`](bpy.types.ActionLayers.html#bpy.types.ActionLayers.remove "bpy.types.ActionLayers.remove") |
user: How do I use Find Node in Blender? Include parameters, examples, warnings and best practices.

assistant: Opens a search pop-up to quickly locate and select a node within the current node tree.
Nodes can be searched by name, socket label, or certain socket values such as strings
and data-block references.

Once a match is selected, the editor view automatically pans and centers on the found node,
highlighting it for easy access.

This operator is especially useful in large node trees for navigating complex networks efficiently.
user: What is Adaptive Sampling and how is it used in Blender Python scripting?

assistant: If the *Noise Threshold* checkbox is enabled, Cycles will use adaptive sampling,
cutting short the sampling process in areas that have become less noisy than the
specified threshold value – in other words, not wasting time further refining
areas that already look good enough. For example, hair on a character may need many samples,
but the background may only need few.

Noise Threshold
:   The threshold to decide whether to continue sampling a pixel.
    Typical values are in the range from 0.1 to 0.001, with lower values meaning better
    quality but longer render times.
    Setting this to 0 makes Cycles guess an automatic value based on the total sample count.

Min Samples
:   The minimum number of samples a pixel receives before adaptive sampling is applied.
    When set to 0 (default), Cycles automatically picks a value determined by the *Noise Threshold*.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Geometry
:   The geometry on which to create instances.

Instance On
:   The geometry element type to instance on.

    Points:
    :   Instances are created at the location of each point.

    Edges:
    :   Instances are placed along edges.

    Faces:
    :   Instances are placed on the surface of each face.

    Corners:
    :   Instances are created at each face corner (vertex per face).

Mask
:   A selection controlling which elements are used for instancing.
    Floating-point values between 0 and 1 are treated as probabilistic selections,
    resulting in a random subset of elements being used.

Input Type
:   Defines how the instance geometry input is provided.

    Data-Block:
    :   Instances are created from an object or collection data-block.

    Geometry:
    :   Instances are created from input geometry provided to the node.

Instance Type Data-Block
:   When using *Data-Block* input, determines whether to instance an *Object* or a *Collection*.

Object / Collection Data-Block
:   The specific object or collection to instance when using *Data-Block* input mode.

Instance Geometry
:   The geometry to instance when using *Geometry* input mode.

Realize Instances
:   Converts all instances into real geometry, producing a single combined geometry output.
    This can be required for some subsequent geometry operations or modifiers.

Keep Surface
:   Keeps the underlying surface used for instancing, rather than outputting only the instances.

Seed
:   Random seed value used to vary random selections or random instance indexing.

### Pick Instance Data-Block Collection

When instancing from a collection, this option enables random or controlled selection
of which child object to instance per element.

Instance Index
:   Determines how a child instance is chosen from the collection.

    Random:
    :   Picks a random object from the collection for each element.

    Sequence:
    :   Cycles through objects in collection order.

    Input:
    :   Uses the value from the *Instance Index* input socket.

Instance Index Input
:   Specifies the index of the object in the collection to be instanced,
    used when the *Instance Index* method is set to *Input*.

### Transform

Surface Offset
:   Moves instances along the element normal, offsetting them from the surface.

Align Rotation
:   Aligns instance rotation to the orientation of the geometry element (e.g., normal direction).

Scale
:   Controls the uniform or per-axis scaling of instances.
user: Describe Creating an Extensions Repository from the Blender manual or Python API, including usage steps and snippets.

assistant: # Creating an Extensions Repository

Third party sites that wish to support extensions in Blender can do so in several ways, in order of complexity:

- [Static](static_repository.xhtml):
  Host a static JSON file listing all the packages of your repository.
- [Dynamic](dynamic_repository.xhtml):
  Serve the JSON file on-demand based on the Blender version and platform.
- [Platform](https://projects.blender.org/infrastructure/extensions-website):
  Fork the entire Extensions Website to create your own.
user: Give a detailed overview of PackedFile(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # PackedFile(bpy_struct)

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

*class* bpy.types.PackedFile(*bpy_struct*)
:   External file packed into the .blend file

    data
    :   Raw data (bytes, exact content of the embedded file)

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

    size
    :   Size of packed file in bytes

        Type:
        :   int in [-inf, inf], default 0, (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 GeometryNodeInputMeshIsland(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeInputMeshIsland(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.GeometryNodeInputMeshIsland(*GeometryNode*)
:   Retrieve information about separate connected regions in a mesh

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Switch Direction in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Switch Direction* operator reverses the direction of the selected Grease Pencil stroke. This means the starting
point of the stroke becomes the endpoint, and vice versa. While this operation does not alter the visual appearance
of the stroke, but affects behaviors that rely on the point order, such as the
[Build Modifier](../../modifiers/generate/build.xhtml).
user: Provide the full official documentation entry for Brush Types, preserving all code examples.

assistant: See [Brush Type](../brush/brush_settings.html#sculpt-tool-settings-brush-type).

Available brush types are listed here, together with brushes from the
*Essentials* asset library using them.

Paint Vertex
:   Brushes: Paint Hard, Paint Soft, Paint Hard Pressure, Paint Soft Pressure, Airbrush

    Paints a specified color over the object.

Blur
:   Brushes: Blur

    Smooths out the colors of adjacent vertices. In this mode the Color
    Value is ignored. The strength defines how much the colors are blurred.

Average
:   Brushes: Average

    Smooths color by painting the average resulting color from all colors under the brush.

Smear
:   Brushes: Smear

    Smudges colors by grabbing the colors under the brush and “dragging” them.
    This can be imagined as a finger painting tool.
user: How do I use Script Loading in Blender? Include parameters, examples, warnings and best practices.

assistant: This may seem obvious, but it is important to note the difference between
executing a script directly and importing a script as a module.

Extending Blender by executing a script directly means the classes that the script defines
remain available inside Blender after the script finishes execution.
Using scripts this way makes future access to their classes
(to unregister them for example) more difficult compared to importing the scripts as modules.
When a script is imported as a module, its class instances will remain
inside the module and can be accessed later on by importing that module again.

For this reason it is preferable to avoid directly executing scripts that extend Blender by registering classes.

Here are some ways to run scripts directly in Blender:

- Loaded in the text editor and press *Run Script*.
- Typed or pasted into the interactive console.
- Execute a Python file from the command line with Blender, e.g:

  ```
  blender --python /home/me/my_script.py
  ```

To run as modules:

- The obvious way, `import some_module` command from the text editor or interactive console.
- Open as a text data-block and check the *Register* option, this will load with the blend-file.
- Copy into one of the directories `scripts/startup`, where they will be automatically imported on startup.
- Define as an add-on, enabling the add-on will load it as a Python module.

### Add-ons

Some of Blender’s functionality is best kept optional,
alongside scripts loaded at startup there are add-ons which are kept in their own directory `scripts/addons`,
They are only loaded on startup if selected from the user preferences.

The only difference between add-ons and built-in Python modules is that add-ons must contain a `bl_info` variable
which Blender uses to read metadata such as name, author, category and project link.
The User Preferences add-on listing uses `bl_info` to display information about each add-on.
[See Add-ons](https://developer.blender.org/docs/handbook/addons/guidelines/)
for details on the `bl_info` dictionary.
user: Describe Add IK to Bone from the Blender manual or Python API, including usage steps and snippets.

assistant: # Add IK to Bone

Adds an [Inverse Kinematics Constraint](../../../constraints/tracking/ik_solver.xhtml) to the active bone.
The operator shows a menu for selecting the target of the constraint:

Without Target
:   Creates the constraint without a *Target*. Only available when no other bone
    or object is selected.

Target New Empty Object
:   Creates an [Empty](../../../../modeling/empties.xhtml) at the bone’s tail and uses it
    as the constraint target. Only available when no other bone or object is
    selected.

Target Selected Bone
:   Sets the target to the selected bone that’s *not* active.

Target Selected Object
:   Sets the target to the selected object that’s *not* active. Either select
    the object before selecting the Armature and entering Pose Mode,
    or select it in the [Outliner](../../../../editors/outliner/introduction.xhtml) when
    already in Pose Mode.

# Remove IK

Removes the [Inverse Kinematics Constraint](../../../constraints/tracking/ik_solver.xhtml) from the selected bones.
user: What is Open and how is it used in Blender Python scripting?

assistant: Opens a file browser to select an image for loading into the editor.
Images can also be opened by dragging and dropping them directly into the editor.

When opening an image, the following options are available:

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

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

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

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

assistant: |  |  |
| --- | --- |
| - [`Collection.exporters`](bpy.types.Collection.html#bpy.types.Collection.exporters "bpy.types.Collection.exporters") - [`CollectionExports.new`](bpy.types.CollectionExports.html#bpy.types.CollectionExports.new "bpy.types.CollectionExports.new") | - [`CollectionExports.remove`](bpy.types.CollectionExports.html#bpy.types.CollectionExports.remove "bpy.types.CollectionExports.remove") |
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Index
:   The [index](../read/input_index.xhtml)
    of the closest element in the same geometry component.

Has Neighbor
:   This is true when the group of the element has at least two elements.
    This is only relevant when using *Group ID*.
user: What is Modes and how is it used in Blender Python scripting?

assistant: Depending on the type of object you are trying to model, there are different types
of modeling [modes](../editors/3dview/modes.xhtml).
Since modes are not specific to modeling they are covered in different parts of the manual.

Switching between modes while modeling is common.
Some tools may be available in more than one mode while others may be unique to a particular mode.

### Edit Mode

Edit Mode is the main mode where modeling takes place.
Edit Mode is used to edit the following types of objects:

- Meshes
- Curves
- Surfaces
- Metaballs
- Text objects
- Lattice

You can only modify the mesh of the objects you are editing.
To modify other objects you can leave Edit Mode, select another object and enter Edit Mode,
or use [Multi-Object Editing](../editors/3dview/modes.xhtml#dview-multi-object-mode).
user: Describe Bevel Vertices from the Blender manual or Python API, including usage steps and snippets.

assistant: # Bevel Vertices

The *Bevel* tool rounds off edges or corners of a mesh at the point of the selected vertices.
In “vertex only” mode, the *Bevel Vertices* tool works on selected vertices
but the option to switch to *Bevel Edges* is available.
By doing so, more vertices are added in order to smooth out profiles with a specified number of *segments*
(see the options below for details about the bevel algorithm).

[image reference removed]

Cubes with and without bevel.
user: What is F-Curves & Channels and how is it used in Blender Python scripting?

assistant: [F-Curves](../editors/graph_editor/fcurves/introduction.html) are the fundamental
unit of animation in Blender, and are the main kind of animation data that
actions contain. Each F-Curve contains keyframes that define how a property
(such as the X location of an object) should change over time.

[image reference removed]

[Graph Editor](../editors/graph_editor/introduction.html), displaying three
F-Curves for three different properties.

Blender’s animation editors (such as the dopesheet, graph editor, etc.) have a
**channel list** on their left side that display animated properties. For
actions, these channels correspond to the F-Curves that animate those
properties.

[image reference removed]

The [Dopesheet Editor’s](../editors/dope_sheet/introduction.html) channel
list, with the animated channels of various bones grouped under their bone
names.

Channels also support a limited form of organization called “channel groups”.
For example, by default Blender creates a channel group for the channels of each
bone. There are a few features in Blender that rely on the groups, but mostly
they are just for your convenience.
user: What is basic.raw_copy and how is it used in Blender Python scripting?

assistant: Single-bone rig type that copies the bone without the `ORG-` name prefix.

Normally all bones copied from the meta-rig are prefixed with `ORG-` and placed on an invisible layer.
This precludes their use as controls or deforming bones, which makes it difficult to transfer complex
fully custom rigging verbatim from the meta-rig.

This rig type does not add the automatic prefix, thus allowing an appropriate `ORG-`, `MCH-` or `DEF-`
prefix to be manually included in the meta-rig bone name, or alternatively using no prefix to create
a control bone.

Relink Constraints
:   Allows retargeting constraints belonging to the bone to point at bones created in the process
    of generating the rig, thus allowing custom rigging to integrate with generated bones.

    To use this feature, add `@` and the intended target bone name to the constraint name, resulting
    in the `...@bone_name` syntax. After all bones of the rig are generated, the constraint target
    bone will be replaced. If the new bone name is just `CTRL`, `MCH` or `DEF`, this will just
    replace the `ORG` prefix in the existing target bone name. For the Armature constraint you can add
    a `@` suffix for each target, or just one `@CTRL`, `@MCH` or `@DEF` suffix to update all.

    Parent
    :   If the field is not empty, applies the same name substitution logic to the parent of the bone.

    When this feature is enabled, the bone will not be automatically parented to the root bone even
    if it has no parent; enter `root` in the *Parent* field if that is necessary.
user: Give a detailed overview of Spline IK: syntax, arguments, return values, common patterns.

assistant: # Spline IK

Spline IK is a constraint which aligns a chain of bones along a curve. By leveraging the ease
and flexibility of achieving aesthetically pleasing shapes offered by curves and
the predictability and well-integrated control offered by bones,
Spline IK is an invaluable tool in the riggers’ toolbox.
It is particularly well suited for rigging flexible body parts such as tails, tentacles,
and spines, as well as inorganic items such as ropes.

Full description of the settings for the spline IK can be found on
the [Spline IK](../../../../constraints/tracking/spline_ik.html) page.
user: Show practical ways to work with Edit Mode in a Blender add-on or script – include code.

assistant: When working with dense geometry, it can become difficult to make subtle adjustments
without causing visible lumps and creases in the model’s surface.
When you face situations like this, Proportional Editing can help.

[image reference removed]

Proportional Editing in Edit Mode.

### Options

Connected Only `Alt`-`O`
:   Rather than using a radius only, the proportional falloff spreads via connected geometry.
    This means that you can proportionally edit the vertices in a finger of a hand
    without affecting the other fingers. While the other vertices are physically close (in 3D space),
    they are far away following the topological edge connections of the mesh.
    The icon will have a blue center when *Connected* is active.
    This mode is only available in *Edit Mode*.

Projected from View
:   Depth along the view is ignored when applying the radius.

    [image reference removed]

    The difference between having “Projected from View” disabled (left) and enabled (right).
user: Give a detailed overview of Self Object Node: syntax, arguments, return values, common patterns.

assistant: # Self Object Node

[image reference removed]

The *Self Object* node outputs the object that contains the geometry nodes modifier
currently being executed. This can be used to retrieve the original transforms.

When evaluated in the [Tool context](../../tools.xhtml#tool-context), this node returns the Active object.
user: Show practical ways to work with Display in a Blender add-on or script – include code.

assistant: You can see these segments only if bones are visualized as *B-bones*.

When not visualized as *B-Bone*s, bones are always shown as rigid sticks,
even though the bone segments are still present and effective.
This means that even in e.g. *Octahedron* visualization,
if some bones in a chain have several segments,
they will nonetheless smoothly deform their geometry.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Domain
:   The type of geometry to extract and split.
    This is also the domain on which the *Selection* and *Group ID* fields are evaluated.

    Point:
    :   Points, spline control points, and vertices.

    Edge:
    :   Mesh edges.

    Face:
    :   Mesh faces.

    Spline:
    :   Curve splines.

    Instance:
    :   Top-level instances. Realized instances are ignored.

    Layer:
    :   Grease Pencil layers.
user: How do I use Select Grouped in Blender? Include parameters, examples, warnings and best practices.

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

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

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

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

Children
:   Select all children of currently selected bones.

Immediate Children
:   Select direct children of currently selected bones.

Parents
:   Select the parents of currently selected bones.

Siblings
:   Select all bones that have the same parent as currently selected bones.
user: Explain CompositorNodeSwitch(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeSwitch(CompositorNode)

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

*class* bpy.types.CompositorNodeSwitch(*CompositorNode*)
:   Switch between two images using a checkbox

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use Gamma Cross Strip in Blender? Include parameters, examples, warnings and best practices.

assistant: # Gamma Cross Strip

The Gamma Cross transition is similar to the [Cross Strip](cross.html) transition,
however, the Gamma Cross strip transition uses color correction while transitioning between the two strips,
resulting in a smoother transition that is easier on the eyes.
user: Give a detailed overview of The Simple Case: syntax, arguments, return values, common patterns.

assistant: Whenever the camera is basically fixed, or at least “almost” stationary, and the footage is crisp and
without motion blur, perfect stabilization is easy to achieve. This might be the case when a tripod was used,
but wind or vibrations on the floor (e.g. on a stage) caused some minor shakes.
Shoulder camera shots done by an experienced operator also frequently fall into this category.

- Use as few points as possible. Start with a single point right on the main subject.
- Track this single point as accurate as possible. Beware of movements and shape changes of the tracked feature.
  Proceed in small increments (e.g. 50 frames), zoom in and readjust the target point manually when it drifts away.
  Another option is to use a larger target area for tracking; since we’re tracking only a single point,
  the slower tracking speed might be acceptable.
- After enabling the basic (location) stabilization, consider if you really need rotation stabilization.
  Often, some minor, slow swinging movements are not really noticeable and do not warrant the additional working time
  and quality loss caused by rotation and scale stabilization.
- For rotation, start with one extra point, well spaced but preferably still attached to the main subject.
- Consider to fix some slow residual motion by manually animating the “*Expected* \*” parameters,
  before you even think of adding more tracking markers. Because doing so is often not worth the effort.
- If you need to add more points, the most important goal is to achieve *symmetry.*
  Place location tracking points symmetrically above and below the horizon.
  Place rotation tracking points into diagonally opposed direction, always centered around the main focal area.
user: Explain PrimitiveFloat(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # PrimitiveFloat(bpy_struct)

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

*class* bpy.types.PrimitiveFloat(*bpy_struct*)
:   RNA wrapped float

    value
    :   Type:
        :   float in [-inf, inf], default 0.0, (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 References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`NodeSeparateBundle.bundle_items`](bpy.types.NodeSeparateBundle.html#bpy.types.NodeSeparateBundle.bundle_items "bpy.types.NodeSeparateBundle.bundle_items") - [`NodeSeparateBundleItems.new`](bpy.types.NodeSeparateBundleItems.html#bpy.types.NodeSeparateBundleItems.new "bpy.types.NodeSeparateBundleItems.new") | - [`NodeSeparateBundleItems.remove`](bpy.types.NodeSeparateBundleItems.html#bpy.types.NodeSeparateBundleItems.remove "bpy.types.NodeSeparateBundleItems.remove") |
user: Give a detailed overview of VIEW3D_AST_brush_gpencil_sculpt(AssetShelf): syntax, arguments, return values, common patterns.

assistant: # VIEW3D_AST_brush_gpencil_sculpt(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_gpencil_sculpt(*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: Explain Selecting Bone Joints in complete detail according to the official Blender documentation.

assistant: To select bones’ joints you have the [standard selection](../../../scene_layout/object/selecting.xhtml) methods.

### Inverse Selection

As stated above, you have to remember that these selection tools are for bones’ joints only,
not the bones’ bodies.

For example, the *Inverse* selection option `Ctrl`-`I`
inverts the selection of bones’ joints, not of bones (see *Inverse selection*).

Remember that a bone is selected only if both its joints are selected. So,
when the selection status of bones’ joints is inverted, a new set of bones is selected.

Inverse selection.

|  |  |
| --- | --- |
| ../../../_images/animation_armatures_bones_selecting_two-bones.png   Two bones selected. | ../../../_images/animation_armatures_bones_selecting_three-ends.png   The result of the inverse selection `Ctrl`-`I`: The bones joints selection has been inverted, and not the bones selection. |

### Selecting Connected Bone Joints

Another example is: when you select the root of a bone connected to its parent,
you also implicitly select the tip of its parent (and vice versa).
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

Drivers are a way to control values of properties by means of a function,
or a mathematical expression.

Effectively, drivers consist of:

- A **driver configuration** that specifies zero, one, or more input values using
  other properties or object transformation channels, and combines them using
  a predefined mathematical function or a custom Python expression.
- An **animation** [F-Curve](../../editors/graph_editor/fcurves/introduction.xhtml)
  that maps the output of the driver configuration to the final value to apply
  to the driven property.

As an example, the rotation of Object 1 can be controlled by the scale of Object 2.
It is then said that the scale of Object 2 *drives* the rotation of Object 1.

Not only can drivers directly set the value of a property to the value of a different one,
they can also combine multiple values using a fixed function or a Python expression
and further modulate it with a manually defined curve and/or a modifier stack.

Drivers are an extremely powerful tool for building rigs and are typically used
to drive bone transforms and the influence of shape keys, action constraints and
modifiers, often using custom properties as inputs.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`MovieTrackingReconstructedCameras.find_frame`](bpy.types.MovieTrackingReconstructedCameras.html#bpy.types.MovieTrackingReconstructedCameras.find_frame "bpy.types.MovieTrackingReconstructedCameras.find_frame") | - [`MovieTrackingReconstruction.cameras`](bpy.types.MovieTrackingReconstruction.html#bpy.types.MovieTrackingReconstruction.cameras "bpy.types.MovieTrackingReconstruction.cameras") |
user: Give a detailed overview of Repeat Last: syntax, arguments, return values, common patterns.

assistant: The Repeat Last feature will repeat your last action when you press `Shift`-`R`.

In the example images below, we duplicated a *Monkey* mesh and moved it a bit.
Using repeat `Shift`-`R`, the *Monkey* was duplicated and moved a second time.

|  |  |  |
| --- | --- | --- |
| ../_images/interface_undo-redo_repeat-last1.png   Suzanne. | ../_images/interface_undo-redo_repeat-last2.png   After a `Shift`-`D` and move. | ../_images/interface_undo-redo_repeat-last3.png   After a `Shift`-`R`. |
user: Give a detailed overview of MATERIAL_UL_matslots(UIList): syntax, arguments, return values, common patterns.

assistant: # MATERIAL_UL_matslots(UIList)

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

*class* bpy.types.MATERIAL_UL_matslots(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *icon*, *_active_data*, *_active_propname*, *_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: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: Bundles are useful in many workflows:

- **Simplified interfaces** – group inputs into a single socket for clarity.
- **Physics simulations** – package all entities and constraints for a solver.
- **Declarative systems** – store complex structured data for evaluation later.
- **Texture sets** – combine PBR maps (Base Color, Roughness, Normal) into one socket.
user: Provide the full official documentation entry for Library(ID), preserving all code examples.

assistant: # Library(ID)

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

*class* bpy.types.Library(*ID*)
:   External .blend file from which data is linked

    archive_libraries
    :   Archive libraries of packed IDs, generated (and owned) by this source library

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

    archive_parent_library
    :   Source library from which this archive of packed IDs was generated

        Type:
        :   [`Library`](#bpy.types.Library "bpy.types.Library"), (readonly)

    filepath
    :   Path to the library .blend file

        Type:
        :   string, default “”, (never None, blend relative `//` prefix supported)

    is_archive
    :   This library is an ‘archive’ storage for packed linked IDs originally linked from its ‘archive parent’ library.

        Type:
        :   boolean, default False, (readonly)

    is_editable
    :   Data-blocks in this library are editable despite being linked. Used by brush assets and their dependencies.

        Type:
        :   boolean, default False, (readonly)

    needs_liboverride_resync
    :   True if this library contains library overrides that are linked in current blendfile, and that had to be recursively resynced on load (it is recommended to open and re-save that library blendfile then)

        Type:
        :   boolean, default False

    packed_file
    :   Type:
        :   [`PackedFile`](bpy.types.PackedFile.html#bpy.types.PackedFile "bpy.types.PackedFile"), (readonly)

    parent
    :   Type:
        :   [`Library`](#bpy.types.Library "bpy.types.Library"), (readonly)

    version
    :   Version of Blender the library .blend was saved with

        Type:
        :   int array of 3 items in [0, inf], default (0, 0, 0), (readonly)

    users_id
    :   ID data-blocks that use this library

        Type:
        :   tuple of [`bpy.types.ID`](bpy.types.ID.html#bpy.types.ID "bpy.types.ID")

        (readonly)

    reload()
    :   Reload this library and all its linked data-blocks

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

assistant: erited Properties Inherited Functions
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Strength
:   Strength of the bump mapping effect, interpolating between no bump mapping and full bump mapping.

Distance
:   Multiplier for the height value to control the overall distance for bump mapping.

Filter Width
:   Filter width in pixels, used to compute the bump mapping direction. For most textures
    the default value of 0.1 enables subpixel filtering for stable results. For stepwise
    textures a larger filter width can be used to get a bevel like effect on edges

Height
:   Scalar value giving the height offset from the surface at the shading point; this is where you plug in textures.

Normal
:   Standard normal input.
user: Explain BMesh Geometry Utilities (bmesh.geometry) in complete detail according to the official Blender documentation.

assistant: # BMesh Geometry Utilities (bmesh.geometry)

This module provides access to bmesh geometry evaluation functions.

bmesh.geometry.intersect_face_point(*face*, *point*)
:   Tests if the projection of a point is inside a face (using the face’s normal).

    Parameters:
    :   - **face** (`bmesh.types.BMFace`) – The face to test.
        - **point** (*float triplet*) – The point to test.

    Returns:
    :   True when the projection of the point is in the face.

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

assistant: A “family” is a way to regroup several meta objects,
producing something very similar to having several metas inside the same object.

It is defined by the left part of an object’s name (the one before the first dot).
Remember, an object’s name is the one in the *Object Name* field, in most panels,
**not** the *Metaball Name* field, which is the meta data-block’s name…
For example, the *family* part of “MetaPlane.001” is `MetaPlane`.
Each meta object in the same “family” is associated with one another as discussed below.

[[image reference removed]](../../_images/modeling_metas_editing_family.png)

Metaball family.

Families of metas are controlled by a *base* meta object which is identified by
an object name **without** a dot in it. For example,
if we have three metas called `MetaThing`, `MetaThing.001`,
`MetaThing.round`, the *base* meta object would be `MetaThing`.

The *base* meta object determines the basis, the resolution, the threshold,
*and* the transformations. It also has the material and texture area.
In a way, the *base* meta is the “owner” of the other metas in the family
(i.e. it is as if the other metas were “included” or joined into the base one).
user: Describe Hints from the Blender manual or Python API, including usage steps and snippets.

assistant: Many modeling tasks involve creating objects that are symmetrical.
This modifier offers a simple and efficient way to do this, with real-time update of the mirror as you edit it.
Once your modeling is completed you can either click *Apply* to make a real version of your mesh,
or leave it as-is for future editing.

### Accurately Positioning the Mirror Plane

To apply a *Mirror* modifier, it is common to have to move the object’s origin onto
the edge or face that is to be the axis for mirroring.
This can be tricky when attempted visually.

A good technique to achieve an exact position is
to select the edge, then [snap](../../../editors/3dview/controls/snapping.xhtml) *Cursor to Selection*.
This will position the 3D Cursor in the center of the edge.
Finally, use the [Set Origin](../../../scene_layout/object/origin.xhtml#bpy-ops-object-origin-set) menu, and select *Origin to 3D Cursor*.
This will move the object’s origin (and thus, the mirror plane) to where the 3D cursor is located,
and the mirroring will be exact.

An alternative is to use an empty as a *Mirror Object* that you move to the correct position.
user: How do I use Script Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Script Node

Cycles Only

[image reference removed]

The *Script Node* allows you to load and use custom shaders written in
[Open Shading Language (OSL)](../../cycles/osl/index.xhtml) within the Cycles renderer.
This node acts as a bridge between OSL shader code and the node-based material system in Blender.

Each Script node represents a single OSL shader, with its inputs
and outputs defined by the parameters in the shader script.
These shaders can be stored directly within the blend-file or referenced externally.

This feature is ideal for technical artists and shader developers
who need fine-grained control over shading behavior beyond what the standard shader nodes provide.
user: How do I use VIEW3D_FH_camera_background_image(FileHandler) in Blender? Include parameters, examples, warnings and best practices.

assistant: # VIEW3D_FH_camera_background_image(FileHandler)

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

*class* bpy.types.VIEW3D_FH_camera_background_image(*FileHandler*)
:   *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 Wave Modifier, preserving all code examples.

assistant: # Wave Modifier

The *Wave* modifier adds a ripple-like motion to an object’s geometry.

This modifier is available for meshes, lattices, curves, surfaces and texts.

|  |  |  |
| --- | --- | --- |
| ../../../_images/modeling_modifiers_deform_wave_example-circular.jpg   Circular wave front. | ../../../_images/modeling_modifiers_deform_wave_example-linear.jpg   Linear wave front. | ../../../_images/modeling_modifiers_deform_wave_example-normals.jpg   Motion enabled for X, Normals enabled for Y. |