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

assistant: # Format String Node

[image reference removed]

The *Format String* node inserts values into a string using either a Python compatible
string format syntax or [Blender’s format specifier](../../../../files/file_paths.xhtml#files-path-templates-specifiers) syntax.

This node simplifies string construction, allowing values to be combined
and formatted without converting numbers to strings or using multiple concatenate nodes.
user: Explain Node Float To Int Items in complete detail according to the official Blender documentation.

assistant: # Node Float To Int Items

ROUND:
:   Round.

    Round the float up or down to the nearest integer.

FLOOR:
:   Floor.

    Round the float down to the next smallest integer.

CEILING:
:   Ceiling.

    Round the float up to the next largest integer.

TRUNCATE:
:   Truncate.

    Round the float to the closest integer in the direction of zero (floor if positive; ceiling if negative).
user: Provide the full official documentation entry for Linked, preserving all code examples.

assistant: Select geometry connected to already selected elements.
This is often useful when a mesh has disconnected, overlapping parts,
where isolating it any other way would be tedious.
To give more control, you can also enable delimiters in the [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel,
so the selection is constrained by seams, sharp edges, materials or UV islands.

With *Pick Linked* you can also select connected geometry directly under the cursor,
using the `L` shortcut to select or `Shift`-`L` to deselect linked.
This works differently in that it uses the geometry under the cursor instead of the existing selection.
user: Provide the full official documentation entry for Geometry Data, preserving all code examples.

assistant: Mesh objects can have different types of custom data attached to them.
This data is mostly used internally and can be exported by some [exporters](../../../files/import_export/index.xhtml).
See [Geometry Data](custom_data.xhtml) for more information.
user: What is Combine Cylindrical Node and how is it used in Blender Python scripting?

assistant: # Combine Cylindrical Node

[image reference removed]

The *Combine Cylindrical* node converts cylindrical coordinates (R, Φ, Z)
into a Cartesian vector (X, Y, Z). It is the inverse of the
[Separate Cylindrical](../../../../modeling/geometry_nodes/utilities/vector/separate_cylindrical.xhtml) node.

This node is useful for constructing positions or directions based on radial distance,
rotation angle, and height, such as creating spiral shapes or cylindrical displacements.
user: Explain ColorManagedDisplaySettings(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # ColorManagedDisplaySettings(bpy_struct)

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

*class* bpy.types.ColorManagedDisplaySettings(*bpy_struct*)
:   Color management specific to display device

    display_device
    :   Display name. For viewing, this is the display device that will be emulated by limiting the gamut and HDR colors. For image and video output, this is the display space used for writing.

        Type:
        :   enum in [`'NONE'`], default `'NONE'`

    emulation
    :   Control how images in the chosen display are mapped to the physical display

        - `OFF`
          Off – Directly output image as produced by OpenColorIO. This is not correct in general, but may be used when the system configuration and actual display device is known to match the chosen display.
        - `AUTO`
          Automatic – Display images consistent with most other applications, to preview images and video for export. A best effort is made to emulate the chosen display on the actual display device..

        Type:
        :   enum in [`'OFF'`, `'AUTO'`], default `'AUTO'`

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # CompositorNodeExposure(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.CompositorNodeExposure(*CompositorNode*)
:   Adjust brightness using a camera exposure parameter

    *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: Give a detailed overview of SpreadsheetTableID(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # SpreadsheetTableID(bpy_struct)

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

subclasses —
[`SpreadsheetTableIDGeometry`](bpy.types.SpreadsheetTableIDGeometry.html#bpy.types.SpreadsheetTableIDGeometry "bpy.types.SpreadsheetTableIDGeometry")

*class* bpy.types.SpreadsheetTableID(*bpy_struct*)
:   Data used to identify a spreadsheet table

    type
    :   The type of the table identifier

        - `GEOMETRY`
          Geometry – Table contains geometry data.

        Type:
        :   enum in [`'GEOMETRY'`], default `'GEOMETRY'`, (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](#bpy.types.SpreadsheetTableID.type "bpy.types.SpreadsheetTableID.type")
user: Give a detailed overview of Duplicate: syntax, arguments, return values, common patterns.

assistant: This operator duplicates the selected control points,
along with the curve segments implicitly selected (if any).
.. If only a handle is selected, the full point will be duplicated too.
The copy is selected so you can move it to another place.
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: Start by loading a video file into the [Movie Clip Editor](../../../editors/clip/introduction.xhtml),
registering the physical object in the [Objects Panel](../../../movie_clip/tracking/clip/sidebar/track/objects.xhtml),
and using [motion tracking](../../../movie_clip/tracking/introduction.xhtml) to track at least
eight [markers](../../../movie_clip/tracking/clip/marker.xhtml) on that physical object.
Then use [Solve Camera/Object Motion](../../../movie_clip/tracking/clip/editing/track.xhtml#bpy-ops-clip-solve-camera) to reconstruct the motion of the physical object,
and finally add this constraint to a Blender object.
user: Explain Extrude in complete detail according to the official Blender documentation.

assistant: # Extrude

When you press `E`, for each selected tip
(either explicitly or implicitly), a new bone is created.
This bone will be the child of “its” tip owner, and connected to it. As usual,
once extrusion is done, only the new bones’ tips are selected, and in select mode,
so you can place them to your liking. See Fig. [Extrusion example.](#fig-rig-bones-extrusion).

Extrusion example.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_editing_extrude_example-1.png   An armature with three selected tips. | ../../../../_images/animation_armatures_bones_editing_extrude_example-2.png   The three extruded bones. |

You also can use the rotating/scaling extrusions,
as with meshes, by pressing respectively `E` `R` and `E` `S` –
as well as [locked](../../../../scene_layout/object/editing/transform/control/axis_locking.html)
extrusion along a global or local axis.

Mirror extrusion example.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_editing_extrude_mirror-1.png   A single selected bone’s tip. | ../../../../_images/animation_armatures_bones_editing_extrude_mirror-2.png   The two mirror-extruded bones. |

Bones have an extra “mirror extruding” tool, called by pressing `Shift`-`E`.
By default, it behaves exactly like the standard extrusion.
But once you have enabled [X-Axis Mirror](../tools/tool_settings.html#bpy-types-armature-use-mirror-x) editing option,
each extruded tip will produce *two new bones*, having the same name except for the “_L”/ “_R” suffix
(for left/right, see the [naming conventions](naming.html#armature-editing-naming-conventions)).
The “_L” bone behaves like the single one produced by the default extrusion –
you can move, rotate or scale it exactly the same way.
The “_R” bone is its mirror counterpart (along the armature’s local X axis),
see Fig. [Mirror extrusion example.](#fig-rig-bone-mirror).

In case you are wondering, you cannot just press `X` to solve this as you would in mesh editing,
because extrusion selects the newly created tips, and as explained below the Delete tool ignores bones’ joints.
To get rid of these extruded bones without undoing, you would have to move the tips,
then select the bones and [delete](delete.html#bpy-ops-armature-delete) them.
user: Describe Orientation from the Blender manual or Python API, including usage steps and snippets.

assistant: Scene orientation tools can be used for orienting object to bundles.

Floor
:   See [Set Origin](../editing/reconstruction.html#bpy-ops-clip-set-origin).

Wall
:   See [Set Floor](../editing/reconstruction.html#bpy-ops-clip-set-plane).

Set Origin
:   See [Set Floor](../editing/reconstruction.html#bpy-ops-clip-set-plane).

Set X, Y Axis
:   See [Set X/Y Axis](../editing/reconstruction.html#bpy-ops-clip-set-axis).

Set Scale
:   See [Set Scale](../editing/reconstruction.html#bpy-ops-clip-set-scale).

Apply Scale
:   See [Apply Solution Scale](../editing/reconstruction.html#bpy-ops-clip-apply-solution-scale).

Distance
:   Distance in active scene units which is used by Set/Apply scale.
user: What is Bake Channels and how is it used in Blender Python scripting?

assistant: Generates new keyframes for the selected curves.

Frame Range
:   The range that will be baked. Defaults to the scene range or preview range.

Frame Step
:   Distance between keyframes. Can be used to create a keyframe every 10 frames or even every half frame.

Remove Outside Range
:   Removes existing keys outside the specified baking range.

Interpolation Type
:   The [interpolation type](../fcurves/properties.xhtml#editors-graph-fcurves-settings-interpolation) for the new keys.

Bake Modifiers
:   If enabled, the new keyframes are based on the modified curve, and the modifiers get deleted.

    If disabled, the new keyframes are based on the original curve, and the modifiers stay applied.
user: Show practical ways to work with Viewport Display in a Blender add-on or script – include code.

assistant: These settings control the curve rendering settings used when the 3D viewport is set to
[Material Preview](../../../editors/3dview/display/shading.html#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: How do I use DampedTrackConstraint(Constraint) in Blender? Include parameters, examples, warnings and best practices.

assistant: # DampedTrackConstraint(Constraint)

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

*class* bpy.types.DampedTrackConstraint(*Constraint*)
:   Point toward target by taking the shortest rotation path

    head_tail
    :   Target along length of bone: Head is 0, Tail is 1

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

    subtarget
    :   Armature bone, mesh or lattice vertex group, …

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

    target
    :   Target object

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

    track_axis
    :   Axis that points to the target object

        Type:
        :   enum in [`'TRACK_X'`, `'TRACK_Y'`, `'TRACK_Z'`, `'TRACK_NEGATIVE_X'`, `'TRACK_NEGATIVE_Y'`, `'TRACK_NEGATIVE_Z'`], default `'TRACK_X'`

    use_bbone_shape
    :   Follow shape of B-Bone segments when calculating Head/Tail position

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

assistant: Index
:   The [index](../../geometry/read/input_index.xhtml) of the element in the selected domain
    to retrieve data from, i.e. “the fourth face”, or “the first control point”.

Value
:   The field to retrieve data from.
user: Provide the full official documentation entry for NodeSocketFloatTime(NodeSocketStandard), preserving all code examples.

assistant: # NodeSocketFloatTime(NodeSocketStandard)

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

*class* bpy.types.NodeSocketFloatTime(*NodeSocketStandard*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    links
    :   List of node links from or to this socket.

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

        (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: What is Outputs and how is it used in Blender Python scripting?

assistant: Geometry
:   The resulting geometry with updated curve attachments.

Surface UV Coordinate
:   The UV coordinate on the surface mesh corresponding to each curve’s attachment point.

Surface Normal
:   The normal vector of the surface mesh evaluated at each curve’s attachment point.
user: What is Material and how is it used in Blender Python scripting?

assistant: # Material

The *Material* modifier alters the base property with a new one taken from a given range mapped on
the current material under the stroke.

You can use various properties of the materials, among which many are mono-component
(i.e. give black-and-white results). In this case for the color modifier, an optional color ramp can be used to
map these gray-scale values to colored ones.
In the reverse case properties of the materials, which are multi-components
(i.e. give RGB results) the mean value will be used for Alpha and Thickness modifiers.

If used with the *Split by Material* option in the *Stroke* tab,
the result will not be blurred between materials along the strokes.

[image reference removed]

Material modifiers demo by T.K.
([blend-file](https://archive.blender.org/wiki/2015/index.php/File:Lilies_Color_Material.zip)).
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: 1. Enable Cryptomatte Object render pass in the Passes panel, and render.
2. In the compositing nodes, create a Cryptomatte node and
   link the Render Layer matching Image and Cryptomatte passes to it.
3. Attach a Viewer node to the Pick output of the Cryptomatte node.
4. Use the Cryptomatte Add/Remove button to sample objects in the Pick Viewer node.
5. Use the Matte output of the Cryptomatte node to get the alpha mask.

### Adding/Removing Layers

By default there are only four crypto layers available as inputs to the Cryptomatte node.
You can add or remove layer inputs through
Sidebar ‣ Item ‣ Properties ‣ Add/Remove Crypto Layer.
These operators will add/remove layers from the bottom of the pass inputs.
user: Explain Editing the Manual in complete detail according to the official Blender documentation.

assistant: # Editing the Manual

You can modify the manual by editing local text files. These files are kept in sync with those online via a
repository, based on this the server will update the online manual.

The manual is written in the [reStructuredText](https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html) (RST) markup language and can be edited
using a plain text editor. For a local preview, you convert (build) the manual source files from RST into HTML web
pages.
user: Show practical ways to work with Transfer Sculpt Mode in a Blender add-on or script – include code.

assistant: Switches Sculpt Mode from the [Active](../../../glossary/index.html#term-Active) object to the object under the mouse.
See [Switching Objects](../../../editors/3dview/modes.html#bpy-ops-object-transfer-mode) for more information.
user: What is Compatibility and how is it used in Blender Python scripting?

assistant: ### Import

Note that the importer is a new addition and lacks many features the exporter supports.

- binary FBX files only.
- Version 7.1 or newer.

#### Missing

- Mesh: shape keys.

### Export

NURBS surfaces, text3D and metaballs are converted to meshes at export time.

#### Missing

Some of the following features are missing because they
are not supported by the FBX format, others may be added later.

- Object instancing – exported objects do not share data,
  instanced objects will each be written with their own data.
- Material textures
- Vertex shape keys – FBX supports them but this exporter does not write them yet.
- Animated fluid simulation – FBX does not support this kind of animation.
  You can however use the OBJ exporter to write a sequence of files.
- Constraints – The result of using constraints is exported as a keyframe animation
  however the constraints themselves are not saved in the FBX.
- Instanced objects – At the moment instanced objects are only written in static scenes
  (when animation is disabled).
user: How do I use SpaceNodeOverlay(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # SpaceNodeOverlay(bpy_struct)

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

*class* bpy.types.SpaceNodeOverlay(*bpy_struct*)
:   Settings for display of overlays in the Node Editor

    preview_shape
    :   Preview shape used by the node previews

        - `FLAT`
          Flat – Use the default flat previews.
        - `3D`
          3D – Use the material preview scene for the node previews.

        Type:
        :   enum in [`'FLAT'`, `'3D'`], default `'FLAT'`

    show_context_path
    :   Display breadcrumbs for the editor’s context

        Type:
        :   boolean, default True

    show_named_attributes
    :   Show when nodes are using named attributes

        Type:
        :   boolean, default True

    show_overlays
    :   Display overlays like colored or dashed wires

        Type:
        :   boolean, default True

    show_previews
    :   Display each node’s preview if node is toggled

        Type:
        :   boolean, default False

    show_reroute_auto_labels
    :   Label reroute nodes based on the label of connected reroute nodes

        Type:
        :   boolean, default False

    show_timing
    :   Display each node’s last execution time

        Type:
        :   boolean, default False

    show_wire_color
    :   Color node links based on their connected sockets

        Type:
        :   boolean, default True

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

assistant: The *Split* operator separates the selected portion of a curve from the rest,
creating a new, independent curve segment.
This curve can then be moved or altered without affecting the other curve.

- If a segment of the curve is selected, it will be split off
  as a new curve that can be moved or edited independently.
- If only a single control point is selected, it will be duplicated as a loose control point,
  while the original remains attached to the rest of the curve.
user: Show practical ways to work with Driver Target Rotation Mode Items in a Blender add-on or script – include code.

assistant: # Driver Target Rotation Mode Items

AUTO:
:   Auto Euler.

    Euler using the rotation order of the target.

XYZ:
:   XYZ Euler.

    Euler using the XYZ rotation order.

XZY:
:   XZY Euler.

    Euler using the XZY rotation order.

YXZ:
:   YXZ Euler.

    Euler using the YXZ rotation order.

YZX:
:   YZX Euler.

    Euler using the YZX rotation order.

ZXY:
:   ZXY Euler.

    Euler using the ZXY rotation order.

ZYX:
:   ZYX Euler.

    Euler using the ZYX rotation order.

QUATERNION:
:   Quaternion.

    Quaternion rotation.

SWING_TWIST_X:
:   Swing and X Twist.

    Decompose into a swing rotation to aim the X axis, followed by twist around it.

SWING_TWIST_Y:
:   Swing and Y Twist.

    Decompose into a swing rotation to aim the Y axis, followed by twist around it.

SWING_TWIST_Z:
:   Swing and Z Twist.

    Decompose into a swing rotation to aim the Z axis, followed by twist around it.
user: Provide the full official documentation entry for VertexPaint(Paint), preserving all code examples.

assistant: # VertexPaint(Paint)

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

*class* bpy.types.VertexPaint(*Paint*)
:   Properties of vertex and weight paint mode

    use_group_restrict
    :   Restrict painting to vertices in the group

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

assistant: Brushes are used as assets, and stored in [asset libraries](../../files/asset_libraries/introduction.html). This makes the
brushes shared across project files. All available brush assets can be displayed in the
[Asset Browser](../../editors/asset_browser.html), which also provides ways to organize them.

Blender comes bundled with a number of brushes in the Essentials asset library. These can be customized into all
kinds of custom brushes by duplicating them (see [Brush Editing](brush_management.html)).

While it’s possible to have brush data-blocks that are local to the file and not marked as assets, such brushes cannot
be activated for actual painting or sculpting. Use the Mark as Asset operator to make them brush assets that can be
activated.
user: Show practical ways to work with Transform in a Blender add-on or script – include code.

assistant: # Transform

When in *Edit Mode* you can use this panel to control position and roll of individual bones.
Whereas in *Pose Mode* you can only set location for the main bone, and you can now set rotation and scale.

In addition, in *Pose Mode* it is possible to restrict changes in position,
rotation and scale by axis on each bone in the armature.

Head X, Y, Z
:   Location of head end of the bone.

Tail X, Y, Z
:   Location of tail end of the bone.

Roll
:   Bone rotation around head-tail axis.

Length
:   The distance from the bone’s head to it’s tail. Changing the length moves the tail end.

Lock
:   Bone is not able to be transformed when in Edit Mode.
user: Provide the full official documentation entry for face.basic_tongue, preserving all code examples.

assistant: Generates a simple tongue, extracted from the original PitchiPoy [super_face](faces.xhtml#rigify-rigs-faces-super-face) rig.

B-Bone Segments (integer)
:   Defines the number of b-bone segments each tweak control will be split into.

Primary Control Layers
:   Optionally specifies bone collections for the main control.
user: How do I use CollectionLightLinking(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CollectionLightLinking(bpy_struct)

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

*class* bpy.types.CollectionLightLinking(*bpy_struct*)
:   Light linking settings of objects and children collections of a collection

    link_state
    :   Light or shadow receiving state of the object or collection

        Type:
        :   enum in [`'INCLUDE'`, `'EXCLUDE'`], default `'INCLUDE'`

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

assistant: Grid
:   The resulting SDF grid with the surface offset by the specified distance.
    The output preserves the SDF property, ensuring that distances remain
    accurate for subsequent operations such as booleans or conversion to a mesh.
user: Describe Install from blender.org from the Blender manual or Python API, including usage steps and snippets.

assistant: Download the Linux version for your architecture and decompress the file to the desired location (e.g. `~/software`
or `/usr/local`).

Blender can now be launched by double-clicking the executable.

When using this method of installation, it is possible to have multiple versions of Blender installed.

For ease of access, you may wish to add a menu entry and create blend-file associations for the file-browser. This can
be done by [Registering Blender](../../editors/preferences/system.xhtml#bpy-ops-preferences-associate-blend).

To make the installation and configuration fully self-contained, set up a [Portable Installation](../../advanced/blender_directory_layout.xhtml#portable-installation).
user: What is Experimental and how is it used in Blender Python scripting?

assistant: # Experimental

These preferences are reserved for features that are currently being worked on and are not yet complete.
Experimental features are only available in [Daily Builds](https://builder.blender.org/download/daily/).

[image reference removed]

Blender Preferences Experimental section.
user: How do I use Solve Camera/Object Motion in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Solve Camera/Object Motion* operator solves the motion of the camera or the
selected [tracked object](../sidebar/track/objects.html),
using all tracks placed on the footage and two keyframes specified on this panel.
There are some requirements:

- There should be at least eight common tracks on the both of the selected keyframes.
- There should be noticeable parallax effects between these two keyframes.

If everything goes smoothly during the solve, the average reprojection error is reported to
the information space and to the Clip editor header. Reprojection error means the average
distance between reconstructed 3D position of tracks projected back to footage and
original position of tracks. Basically, reprojection error below 0.3 means accurate reprojection,
(0.3 - 3.0) means quite nice solving which still can be used.
Values above 3 means some tracks should be tracked more accurately,
or that values for focal length or distortion coefficients were set incorrectly.
user: Provide the full official documentation entry for Headings, preserving all code examples.

assistant: Use the following hierarchy for headings:

```
#################
  Document Part
#################

****************
Document Chapter
****************

Document Section
================

Document Subsection
-------------------

Document Subsubsection
^^^^^^^^^^^^^^^^^^^^^^

Document Paragraph
""""""""""""""""""
```
user: Give a detailed overview of Creating Vertex Groups: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Empty Vertex Groups panel.

Vertex groups are maintained within the *Object Data* tab (1) in the Properties.
As long as no vertex groups are defined (the default for new mesh objects),
the panel is empty (2).

You create a vertex group by `LMB` on the  button on the right panel border (3).
Initially the group is named “Group” (or “Group.nnn” when the name already exists) and
gets displayed in the panel (2) (see next image).

### Vertex Groups Panel Controls

[image reference removed]

One vertex group.

Once a new vertex group has been added, the new group appears
in the Vertex Groups panel. There you find three clickable elements:

Group Name
:   The group name can be changed by double-clicking `LMB` on the name itself.
    Then you can edit the name as you like.

Filter (arrow icon)
:   When the little arrow icon in the left lower corner is clicked, a new row opens up
    where you can enter a search term. This becomes handy when the number of
    vertex groups gets big.

Drag Handle
:   If you have a large number of vertex groups and you want to see more
    than a few groups, you can `LMB` on the small drag handle to make
    the vertex groups list larger or smaller.

Active Group
:   When a vertex group is created,
    then it is also automatically marked as the *Active Group*.
    This is indicated by setting the background of the panel entry
    to a light gray color. If you have two or more groups in the list,
    then you can change the active group by `LMB` on
    the corresponding entry in the Vertex Groups panel.
user: Provide the full official documentation entry for Examples, preserving all code examples.

assistant: [image reference removed]

Here, the *Count* mode of the [Resample Curve Node](../operations/resample_curve.html) is recreated,
except a mesh is used for the result instead of a curve. The Z axis of the position can be used
as the sample factor because the position is between zero and one for the entire line.
user: How do I use Grid Divergence Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Grid Divergence Node

[image reference removed]

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

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

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

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

\[\nabla \cdot \mathbf{F} =
\frac{\partial F_x}{\partial x} +
\frac{\partial F_y}{\partial y} +
\frac{\partial F_z}{\partial z}\]
user: Provide the full official documentation entry for Brush Settings, preserving all code examples.

assistant: # Brush Settings

Painting needs paint brushes and Blender provides a Brush panel within the Toolbar
when in *Vertex Paint Mode*.

Brush
:   In the [Data-Block menu](../../../../interface/controls/templates/data_block.xhtml#ui-data-block) you find predefined Brush presets.
    And you can create your own custom presets as needed.

Radius
:   This option controls the radius of the brush, measured in pixels.
    `F` allows you to change the brush size interactively by
    dragging the mouse and then `LMB` (the texture of the brush should be visible inside the circle).
    Typing a number then enter while using `F` allows you to enter the size numerically.

    (Size Pressure)
    :   Adjusts the brush radius based on the stylus pressure when using a [Graphics Tablet](../../../../getting_started/configuration/hardware.xhtml#hardware-tablet).

Strength
:   How powerful the brush is when applied.

    (Strength Pressure)
    :   Adjusts the brush strength based on the stylus pressure when using a [Graphics Tablet](../../../../getting_started/configuration/hardware.xhtml#hardware-tablet).

Mode
:   Stroke:
    :   Only paint over strokes.

    Fill:
    :   Only paint over fill areas.

    Stroke & Fill:
    :   Paint over strokes and fill areas.

Cursor
:   See the global brush settings for [Cursor](../../../../sculpt_paint/brush/cursor.xhtml) settings.
user: Give a detailed overview of Creating Custom Gizmos: syntax, arguments, return values, common patterns.

assistant: Adding custom gizmos to a node group that generates or modifies geometry can make it more convenient to use.

To add a gizmo to a node group, one has to use one of the [gizmo nodes](input/gizmo/index.xhtml#gizmo-nodes-overview).
The main aspect that makes gizmos unintuitive at first is that there is a **bidirectional dependency**:
changing the gizmo position changes the controlled value and vice versa.

The most simple custom gizmo setup is shown below.
The Linear Gizmo node adds a gizmo that is drawn in the 3D viewport.
The gizmo controls the value that is plugged into it.
When trying this, you will notice that the gizmo always jumps back to the origin while the value is still changed.
That is because the Position of the gizmo node does not depend on the value yet.

[image reference removed]

The simplest custom gizmo setup.

When the gizmo position is made dependent on the value, the gizmo works more than one would expect.
It now also works in both directions: changing the value moves the gizmo and moving the gizmo changes the value.

[image reference removed]

Simple gizmo setup where the gizmo position depends on the controlled value.

Multiple values can be plugged into the Value input of gizmo nodes at once.
In that case, all these values are modified at the same time when moving the gizmo.
Multiply or divide nodes can be used if the values should change at different rates.

The Transform output of gizmo nodes should be joined into the geometry that the gizmo controls.
This helps Blender to understand that the gizmos should be transformed together with the geometry later on.

[image reference removed]

Example showing how to add simple gizmos to the built-in [Grid](mesh/primitives/grid.xhtml#bpy-types-geometrynodemeshgrid) node.
user: How do I use NodeInternalSocketTemplate(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeInternalSocketTemplate(bpy_struct)

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

*class* bpy.types.NodeInternalSocketTemplate(*bpy_struct*)
:   Type and default value of a node socket

    identifier
    :   Identifier of the socket

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

    name
    :   Name of the socket

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

    type
    :   Data type of the socket

        Type:
        :   enum in [Node Socket Type Items](bpy_types_enum_items/node_socket_type_items.html#rna-enum-node-socket-type-items), default `'VALUE'`, (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](#bpy.types.NodeInternalSocketTemplate.type "bpy.types.NodeInternalSocketTemplate.type")
user: Give a detailed overview of MeshLoop(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # MeshLoop(bpy_struct)

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

*class* bpy.types.MeshLoop(*bpy_struct*)
:   Loop in a Mesh data-block

    bitangent
    :   Bitangent vector of this vertex for this face (must be computed beforehand using calc_tangents, use it only if really needed, slower access than bitangent_sign)

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

    bitangent_sign
    :   Sign of the bitangent vector of this vertex for this face (must be computed beforehand using calc_tangents, bitangent = bitangent_sign \* cross(normal, tangent))

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

    edge_index
    :   Edge index

        Type:
        :   int in [0, inf], default 0

    index
    :   Index of this loop

        Type:
        :   int in [0, inf], default 0, (readonly)

    normal
    :   The normal direction of the face corner, taking into account sharp faces, sharp edges, and custom normal data

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

    tangent
    :   Local space unit length tangent vector of this vertex for this face (must be computed beforehand using calc_tangents)

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

    vertex_index
    :   Vertex index

        Type:
        :   int in [0, inf], default 0

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: - The **Edit** scene has a default length of **10 seconds**, providing a concise overview of
  the full storyboard sequence.
- Each **shot scene** is set to **2 seconds** by default, offering a shorter duration that makes
  it easier to visualize pacing in the Sequencer.
- Frame ranges are shortened compared to typical defaults (e.g., 250 frames) to make timeline
  navigation more practical for storyboard editing.
user: Show practical ways to work with Viewport Stereo 3D in a Blender add-on or script – include code.

assistant: When you enable *Views* in the Render Layer panel, a new area is available in the 3D Viewport Sidebar region.
In this panel you can pick whether to see the stereo 3D in the viewport, or which camera to see.
It also allow you to see the *Cameras*, the *Plane* and the *Volume* of the stereo cameras.

[image reference removed]

Viewport stereo 3D settings.

Cameras
:   When working with the Stereo 3D Viewports setup, you can inspect what
    each individual generated camera is looking or the combined result of them.
    In the Multi-View mode you can see the combined result of the left and right cameras
    (when available) or the current selected camera.

Plane
:   The convergence plane represents the screen as it is perceived by the audience.
    Visualizing it in the 3D Viewport allows you to layout your scene
    based on your depth script outside the camera view.

Volume
:   The intersection of the stereo cameras frustums helps planning the show
    by avoiding elements being visible by only one camera.
    The volume is defined by the camera’s start and end clipping distances.
    The areas that are in the frustum of one camera only are known as *retinal rivalry areas*.
    They are tolerated in the negative space (the region from the convergence plane into the image)
    but are to be avoided at all costs in the positive space (the area from the convergence plane to the camera).

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

    Viewport 3D: convergence plane and volume display.
user: Explain Tool Settings in complete detail according to the official Blender documentation.

assistant: Layer
:   Restrict interpolation to either the *Active Layer* or *All Layers*.

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

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

Flip Mode
:   Reverses the interpolation direction, swapping the start and end strokes.
    *Automatic* mode attempts to determine the correct direction for each stroke automatically.

Smooth
:   The amount of smoothing applied to interpolated strokes to reduce jitter or visual noise.

Iterations
:   The number of times smoothing is applied to newly created strokes.
    Higher values result in smoother interpolation but may reduce shape fidelity.
user: Provide the full official documentation entry for Copy As New Driver, preserving all code examples.

assistant: A driver that sets the property value to the value of a different property can be
quickly created by using the *Copy As New Driver* context menu option of the input
property, and then pasting the result onto the output property via *Paste Driver*.

It is also possible to add the new driver variable to an existing driver using
the [Paste Driver Variables](drivers_panel.xhtml#drivers-variables) button in the editor panel.
user: Explain Wipe Strip in complete detail according to the official Blender documentation.

assistant: # Wipe Strip

The *Wipe* transition strip can be used to transition from one strip to the next.
The wipe will have no effect if created from a single strip instead of two strips.
The duration of the wipe is the intersection of the two source strips and cannot be adjusted.
To adjust the start and end of the wipe you must adjust the temporal bounds of the source strips
in a way that alters their intersection.
user: Give a detailed overview of Graph View: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Driver curve in the Drivers editor.

The main area of the [Drivers editor](../../editors/drivers_editor.html)
shows an [F-Curve](../../editors/graph_editor/fcurves/introduction.html) that
represents the driver function.

The **X axis** maps to the output value of the driver configuration. The units depend on the setup.

The **Y axis** shows the value applied to the target property. The units depend on the property.

In the example image, if the driver value is 2.0 the property value will be 0.5.

The default F-Curve is an identity map, i.e. the value produced by the driver configuration
is applied to the driven property unchanged. If the driver output value is 2.0,
the property will be 2.0.

The driver function can be defined artistically with Bézier curve handles or
mathematically with trigonometric functions or polynomial expressions such as \(y = a + bx\).
Furthermore, the function can also be procedurally modulated with noise or cyclic repetitions.
See [Modifiers](../../editors/graph_editor/fcurves/modifiers.html) for more details.