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

assistant: [image reference removed]

Follow Track constraint.

Active Clip
:   Whether the tracking marker is in the scene’s [Active Clip](../../../scene_layout/scene/properties.xhtml#bpy-types-scene-active-clip).
    If unchecked, a selector appears for choosing another clip.

3D Position
:   Whether to use the tracking marker’s reconstructed world position (instead of its position
    in the flat video).

Undistort
:   Whether to use the tracking marker’s video position after compensating for lens distortion
    (see [Lens settings](../../../movie_clip/tracking/clip/sidebar/track/camera.xhtml#motion-tracking-camera-lens)).
    Not available when *3D Position* is checked.

Frame Method
:   How to handle a difference in aspect ratio between the tracked video footage and the rendered image.

    Stretch:
    :   The object is positioned as though the video were stretched to exactly match the size of the
        rendered image.

    Fit:
    :   The object is positioned as though the video were made as large as possible while still keeping
        its original aspect ratio and fitting inside the rendered image along both axes.

    Crop:
    :   The object is positioned as though the video were made as large as possible while still keeping
        its original aspect ratio and fitting inside the rendered image along one axis.

Object
:   The physical object containing the tracking marker to follow. See the
    [Objects Panel](../../../movie_clip/tracking/clip/sidebar/track/objects.xhtml) in the Movie Clip Editor.
    If left empty, *Track* will list the markers used to reconstruct the physical camera.

Track
:   The tracking marker to follow.

Camera
:   The Blender camera in whose field of view the constrained object should appear.
    If left empty, the scene’s [active camera](../../../scene_layout/scene/properties.xhtml#bpy-types-scene-camera) is used.

Depth Object
:   If this object is set, the constrained object will be projected onto its surface.
    This can be used to create a facial makeup effect, for example.
    Not available when *3D Position* is checked.

Constraint to F-Curve
:   Replaces the constraint by a set of equivalent [keyframes](../../keyframes/introduction.xhtml).

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects its owner.
user: Explain Main View in complete detail according to the official Blender documentation.

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

### Adjusting the View

Panning is done by dragging `MMB`.

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

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

### Frame Range

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

### Keyframes

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

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

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

### Markers

See the [Markers page](../animation/markers.html) for more information.
user: Describe NodesModifierBake(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodesModifierBake(bpy_struct)

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

*class* bpy.types.NodesModifierBake(*bpy_struct*)
:   bake_id
    :   Identifier for this bake which remains unchanged even when the bake node is renamed, grouped or ungrouped

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

    bake_mode
    :   - `ANIMATION`
          Animation – Bake a frame range.
        - `STILL`
          Still – Bake a single frame.

        Type:
        :   enum in [`'ANIMATION'`, `'STILL'`], default `'ANIMATION'`

    bake_target
    :   Where to store the baked data

        - `INHERIT`
          Inherit from Modifier – Use setting from the modifier.
        - `PACKED`
          Packed – Pack the baked data into the .blend file.
        - `DISK`
          Disk – Store the baked data in a directory on disk.

        Type:
        :   enum in [`'INHERIT'`, `'PACKED'`, `'DISK'`], default `'INHERIT'`

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

    directory
    :   Location on disk where the bake data is stored

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

    frame_end
    :   Frame where the baking ends

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

    frame_start
    :   Frame where the baking starts

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

    node
    :   Bake node or simulation output node that corresponds to this bake. This node may be deeply nested in the modifier node group. It can be none in some cases like missing linked data blocks.

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

    use_custom_path
    :   Specify a path where the baked data should be stored manually

        Type:
        :   boolean, default False

    use_custom_simulation_frame_range
    :   Override the simulation frame range from the scene

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

assistant: The quickest way to constrain two objects is to select both and
click the *Connect* button in Object ‣ Rigid Body.
This creates a new empty object (named “Constraint”) with a physics constraint
already attached and pointing at the two selected objects.
user: Explain NodeSocketVectorVelocity2D(NodeSocketStandard) in complete detail according to the official Blender documentation.

assistant: # NodeSocketVectorVelocity2D(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.NodeSocketVectorVelocity2D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], default (0.0, 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: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Menu
:   Determines which input socket is passed through to the output.

One input is created for each menu entry. The input corresponding to the selected menu item
is evaluated and passed through.

Menu item labels can be renamed using `Ctrl`-`LMB` on the socket name or in the node’s *Properties* panel.

Additional input sockets can be added by:
- Dragging a connection onto the empty socket at the bottom of the list.
- Clicking the  icon in the node header.

Unused inputs are not computed, improving performance in complex node networks.
user: What is MetaElement(bpy_struct) and how is it used in Blender Python scripting?

assistant: # MetaElement(bpy_struct)

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

*class* bpy.types.MetaElement(*bpy_struct*)
:   Blobby element in a metaball data-block

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

    hide
    :   Hide element

        Type:
        :   boolean, default False

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

    rotation
    :   Normalized quaternion rotation

        Type:
        :   [`mathutils.Quaternion`](mathutils.html#mathutils.Quaternion "mathutils.Quaternion") rotation of 4 items in [-inf, inf], default (0.0, 0.0, 0.0, 0.0)

    select
    :   Select element

        Type:
        :   boolean, default False

    size_x
    :   Size of element, use of components depends on element type

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

    size_y
    :   Size of element, use of components depends on element type

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

    size_z
    :   Size of element, use of components depends on element type

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

    stiffness
    :   Stiffness defines how much of the element to fill

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

    type
    :   Metaball type

        Type:
        :   enum in [Metaelem Type Items](bpy_types_enum_items/metaelem_type_items.html#rna-enum-metaelem-type-items), default `'BALL'`

    use_negative
    :   Set metaball as negative one

        Type:
        :   boolean, default False

    use_scale_stiffness
    :   Scale stiffness instead of radius

        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](#bpy.types.MetaElement.type "bpy.types.MetaElement.type")
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.active_action`](bpy.context.html#bpy.context.active_action "bpy.context.active_action") - [`bpy.context.selected_editable_actions`](bpy.context.html#bpy.context.selected_editable_actions "bpy.context.selected_editable_actions") - [`bpy.context.selected_visible_actions`](bpy.context.html#bpy.context.selected_visible_actions "bpy.context.selected_visible_actions") - [`ActionConstraint.action`](bpy.types.ActionConstraint.html#bpy.types.ActionConstraint.action "bpy.types.ActionConstraint.action") - [`AnimData.action`](bpy.types.AnimData.html#bpy.types.AnimData.action "bpy.types.AnimData.action") - [`AnimData.action_tweak_storage`](bpy.types.AnimData.html#bpy.types.AnimData.action_tweak_storage "bpy.types.AnimData.action_tweak_storage") - [`BlendData.actions`](bpy.types.BlendData.html#bpy.types.BlendData.actions "bpy.types.BlendData.actions") - [`BlendDataActions.new`](bpy.types.BlendDataActions.html#bpy.types.BlendDataActions.new "bpy.types.BlendDataActions.new") | - [`BlendDataActions.remove`](bpy.types.BlendDataActions.html#bpy.types.BlendDataActions.remove "bpy.types.BlendDataActions.remove") - `GLTF2_filter_action.action` - [`NlaStrip.action`](bpy.types.NlaStrip.html#bpy.types.NlaStrip.action "bpy.types.NlaStrip.action") - [`NlaStrips.new`](bpy.types.NlaStrips.html#bpy.types.NlaStrips.new "bpy.types.NlaStrips.new") - [`Pose.apply_pose_from_action`](bpy.types.Pose.html#bpy.types.Pose.apply_pose_from_action "bpy.types.Pose.apply_pose_from_action") - [`Pose.backup_create`](bpy.types.Pose.html#bpy.types.Pose.backup_create "bpy.types.Pose.backup_create") - [`Pose.blend_pose_from_action`](bpy.types.Pose.html#bpy.types.Pose.blend_pose_from_action "bpy.types.Pose.blend_pose_from_action") - [`WindowManager.poselib_previous_action`](bpy.types.WindowManager.html#bpy.types.WindowManager.poselib_previous_action "bpy.types.WindowManager.poselib_previous_action") |
user: How do I use Metadata in Blender? Include parameters, examples, warnings and best practices.

assistant: Metadata on parameters controls how they are displayed in the user interface.
The following metadata entries are supported:

`[[ string label = "My Label" ]]`
:   Custom display name of the parameter in the user interface.

`[[ string widget = "null" ]]`
:   Hides the parameter from the user interface.

`[[ string widget = "boolean" ]]` or `[[ string widget = "checkbox" ]]`
:   Displays an integer parameter as a boolean checkbox.

`[[ string widget = "filename" ]]`
:   Displays the parameter as a file path selector.

`[[ string widget = "mapper", string options = "left:0|right:1" ]]`
:   Displays an integer parameter as an enumerated menu.
    The *options* string defines a list of label-value pairs separated by `|`.

`[[ string vecsemantics = "POINT" ]]`
:   Marks a vector parameter as a translation input (position vector).

`[[ string vecsemantics = "NORMAL" ]]`
:   Marks a vector parameter as a normal input (direction vector).

`[[ string unit = "radians" ]]`
:   Marks a float parameter as an angle input, displayed in radians.

`[[ string unit = "m" ]]`
:   Marks a float parameter as a distance input, displayed in meters.

`[[ string unit = "s" ]]` or `[[ string unit = "sec" ]]`
:   Marks a float parameter as a time input, displayed in seconds.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Face Index
:   The index of the face for which to find the corners.

Weights
:   The weights of the corners in the geometry. Unlike the other inputs which follow
    the context domain, this one is always evaluated in the Face Corner domain.

    The corners are sorted by their associated weight in ascending order.
    Corners with the same weight are sorted by their index.

Sort Index
:   The 0-based index of the corner to select from the face’s sorted corners.
    If this value is outside the range of valid indices, it wraps around.
user: How do I use NodeTreeInterfaceSocketFloatUnsigned(NodeTreeInterfaceSocket) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeTreeInterfaceSocketFloatUnsigned(NodeTreeInterfaceSocket)

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

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

    default_value
    :   Input value used for unconnected socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

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

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

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

assistant: # Brush Settings

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 radius based on the stylus pressure when using a [Graphics Tablet](../../../../getting_started/configuration/hardware.xhtml#hardware-tablet).

Strength
:   Controls how much each application of the brush affects the model.
    For example, higher values cause the *Randomize* brush to add noise to the strokes more quickly,
    and cause the *Smooth* brush to soften the strokes more quickly.

    You can change the brush strength interactively by pressing `Shift`-`F`
    in the 3D Viewport and then moving the brush and then `LMB`.
    You can enter the size numerically also while in `Shift`-`F` sizing.

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

Use Falloff
:   When enabled, use Strength falloff for the brush.
    Brush Strength decays with the distance from the center of the brush.

Sculpt Strokes
:   Filters the effect of the brush over the strokes.
    Applies to *Smooth* and *Randomize* brushes only.

    Affect Position
    :   Toggles the brush effect on the position of the stroke points.

    Affect Strength
    :   Toggles the brush effect on the strength (alpha) of the stroke points.

    Affect Thickness
    :   Toggles the brush effect on the thickness of the stroke points.

    Affect UV
    :   Toggles the brush effect on the UV rotation of the stroke points.

Direction
:   The influence direction of the brush. This can be Add or Subtract.
user: Show practical ways to work with TexPaintSlot(bpy_struct) in a Blender add-on or script – include code.

assistant: # TexPaintSlot(bpy_struct)

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

*class* bpy.types.TexPaintSlot(*bpy_struct*)
:   Slot that contains information about texture painting

    icon_value
    :   Paint slot icon

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

    is_valid
    :   Slot has a valid image and UV map

        Type:
        :   boolean, default False, (readonly)

    name
    :   Name of the slot

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

    uv_layer
    :   Name of UV map

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Join Bundle Node in complete detail according to the official Blender documentation.

assistant: # Join Bundle Node

[image reference removed]

The *Join Bundle* node combines multiple bundles into a single output bundle.
Each connected input bundle is merged together, producing one bundle
that contains all items from the inputs.
user: How do I use Realize Instances Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Realize Instances Node

[image reference removed]

The *Realize Instances* node makes any instances (efficient duplicates of the same geometry)
into real geometry data. This makes it possible to affect each instance individually,
whereas without this node, the exact same changes are applied to every instance of
the same geometry. However, performance can become much worse when the input
contains many instances of complex geometry, which is a fundamental limitation
when procedurally processing geometry.
user: Explain GeometryNodeMeshCone(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeMeshCone(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.GeometryNodeMeshCone(*GeometryNode*)
:   Generate a cone mesh

    fill_type
    :   Type:
        :   enum in [Node Geometry Mesh Circle Fill Type Items](bpy_types_enum_items/node_geometry_mesh_circle_fill_type_items.html#rna-enum-node-geometry-mesh-circle-fill-type-items), default `'NGON'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Extrude Manifold

This tool is very similar to [Extrude Faces](../editing/face/extrude_faces.html)
but enables *Dissolve Orthogonal Edges* by default.
This causes the tool to automatically split and remove adjacent faces when extruding inwards.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`SceneDisplay.shading`](bpy.types.SceneDisplay.html#bpy.types.SceneDisplay.shading "bpy.types.SceneDisplay.shading") - [`SpaceView3D.shading`](bpy.types.SpaceView3D.html#bpy.types.SpaceView3D.shading "bpy.types.SpaceView3D.shading") | - [`XrSessionSettings.shading`](bpy.types.XrSessionSettings.html#bpy.types.XrSessionSettings.shading "bpy.types.XrSessionSettings.shading") |
user: What is Animation and how is it used in Blender Python scripting?

assistant: There are two ways to add keyframes through Python.

The first is through key properties directly, which is like inserting a keyframe from the button as a user.
You can also manually create the curves and keyframe data, then set the path to the property.
Here are examples of both methods. Both insert a keyframe on the active object’s Z axis.

Simple example:

```
obj = bpy.context.object
obj.location[2] = 0.0
obj.keyframe_insert(data_path="location", frame=10.0, index=2)
obj.location[2] = 1.0
obj.keyframe_insert(data_path="location", frame=20.0, index=2)
```

Using low-level functions:

```
obj = bpy.context.object

# Create the action, with a slot for the object, a layer, and a keyframe strip:
action = bpy.data.actions.new(name="MyAction")
slot = action.slots.new(obj.id_type, obj.name)
strip = action.layers.new("MyLayer").strips.new(type='KEYFRAME')

# Create a channelbag to hold the F-Curves for the slot:
channelbag = strip.channelbag(slot, ensure=True)

# Create the F-Curve with two keyframes:
fcu_z = channelbag.fcurves.new(data_path="location", index=2)
fcu_z.keyframe_points.add(2)
fcu_z.keyframe_points[0].co = 10.0, 0.0
fcu_z.keyframe_points[1].co = 20.0, 1.0

# Assign the action and the slot to the object:
adt = obj.animation_data_create()
adt.action = action
adt.action_slot = slot
```
user: Show practical ways to work with ColorStrip(EffectStrip) in a Blender add-on or script – include code.

assistant: # ColorStrip(EffectStrip)

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

*class* bpy.types.ColorStrip(*EffectStrip*)
:   Sequence strip creating an image filled with a single color

    color
    :   Effect Strip color

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

    input_count
    :   Type:
        :   int in [0, 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: Show practical ways to work with Show/Hide in a Blender add-on or script – include code.

assistant: ### Mute

Muting a node removes its contribution to the node tree,
and makes all links pass through it without change.
Links will appear red as an indicator of passing through the muted node.

### Node Preview

Shows/Hides a preview region on the node that displays the frame
after that node’s operation has been applied. This can also be toggled
by clicking the material ball icon in the node header.

### Node Options

Shows/Hides all node properties.

### Unconnected Sockets

Collapses/Expands any input or output sockets that have no other nodes connected to them.

### Collapse

Collapses the node so only the node header is visible.
This can also be toggled by clicking the triangle on the left of the node header.

### Collapse and Hide Unused Sockets

Applies both the [Unconnected Sockets](#bpy-ops-node-hide-socket-toggle) and [Collapse](#bpy-ops-node-hide-toggle) operations.
user: Describe GeometryNodeSetMaterial(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeSetMaterial(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.GeometryNodeSetMaterial(*GeometryNode*)
:   Assign a material to geometry elements

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

assistant: Geometry
:   Standard geometry input.

Selection
:   Boolean field that is true for parts of the geometry to be deleted.
    Unselected points will be completely unused for the operation–
    they will not be merged into other points, and no points will merge into them either.

Mode
:   Method for choosing which vertices are merged.

    All:
    :   Merge includes all geometry including loose parts.

    Connected:
    :   Merge only includes attached geometry i.e. the modifier will not merge loose parts together.

Distance
:   The distance to use for searching for nearby points.
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: X, Y, Z
:   The integer indices of the current voxel in the grid along each axis.

    These values identify which voxel is being sampled by the field at this
    evaluation point. They can be offset (for example, add or subtract 1 on X)
    and then passed to [Sample Grid Index](../sample/sample_grid_index.xhtml)
    to read values from neighboring voxels.

### Tile

Is Tile
:   Whether the current evaluation is happening on a *tile* rather than on a
    single voxel.

    Some operations evaluate fields on tiles that cover multiple voxels at
    once for performance reasons. In those cases the coordinates given by
    *X*, *Y*, and *Z* alone are not enough to describe the full covered region.

    If this is false, the extent is always 1.

Extent X, Extent Y, Extent Z
:   The number of voxels along each axis of the tile.

    For a normal voxel, the extent on each axis is `1`.
    For a tile that covers multiple voxels, the extents describe how many
    voxels are grouped together in X, Y, and Z.

    These outputs can be used to detect and handle cases where an evaluation
    represents an aggregated region (a tile) instead of an individual voxel,
    so that the result is not misinterpreted as referring to just one voxel.
user: Describe Initialize Face Sets from the Blender manual or Python API, including usage steps and snippets.

assistant: Initializes all face sets on the mesh at once based off one of several mesh attribute properties.

Mode
:   The mesh data attribute used to define the boundaries for the face sets.

    By Loose Parts:
    :   Creates a new face set per discontinuous part of the mesh.

    By Face Set Boundaries:
    :   Creates a face set for each isolated face set.
        This mode is useful for splitting the patterns created by [Face Set Expand](expand.xhtml#face-set-expand)
        into individual Face Sets for further editing.

    By Materials:
    :   Creates a face set per [Material Slot](../../../render/materials/assignment.xhtml#bpy-types-materialslot).

    By Normals:
    :   Creates face sets for Faces that have similar [Normals](../../../modeling/meshes/structure.xhtml#modeling-meshes-structure-normals).

    By UV Seams:
    :   Creates face sets using [UV Seams](../../../modeling/meshes/uv/unwrapping/seams.xhtml) as boundaries.

    By Edge Creases:
    :   Creates face sets using [Edge Creases](../../../modeling/meshes/editing/edge/edge_data.xhtml#bpy-ops-transform-edge-crease) as boundaries.

    By Edge Bevel Weight:
    :   Creates face sets using [Bevel Weights](../../../modeling/meshes/editing/edge/edge_data.xhtml#bpy-ops-transform-edge-bevelweight) as boundaries.

    By Sharp Edges:
    :   Creates face sets using [Sharp Edges](../../../modeling/meshes/editing/edge/edge_data.xhtml#bpy-ops-mesh-mark-sharp) as boundaries.

Threshold
:   The minimum value to consider a certain attribute a boundary when creating the face sets.
user: Explain Usage in complete detail according to the official Blender documentation.

assistant: ### Aliases

Some variables and modules are available for convenience:

- `C`: Quick access to `bpy.context`.
- `D`: Quick access to `bpy.data`.
- `bpy`: Top level Blender Python API module.

### First Look at the Console Environment

To see the list of global functions and variables,
type `dir()` and press `Return` to execute it.

[image reference removed]

### Auto Completion

The Console can preview the available members of a module or variable.
As an example, type `bpy.` and press `Tab`:

[image reference removed]

The submodules are listed in green. Attributes and methods will be listed
in the same way, with methods being indicated by a trailing `(`.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

The NonLinear Animation editor, or NLA editor for short, lets you animate on a higher level.
Instead of working with individual keyframes, it works with [actions](../../animation/actions.xhtml),
which are named, reusable animation segments.

[image reference removed]

The NLA editor.
user: Provide the full official documentation entry for Select Face Loops, preserving all code examples.

assistant: In face select mode, holding `Alt` while selecting an *edge* selects a loop of
faces that are connected in a line end-to-end, along their opposite edges.

In vertex select mode,
the same can be accomplished by using `Ctrl`-`Alt` to select an edge,
which selects the face loop implicitly.

[image reference removed]

Face loop selection.

This face loop was selected by clicking with `Alt`-`LMB` on an edge,
in *face* select mode.
The loop extends perpendicular from the edge that was selected.

[image reference removed]

`Alt` versus `Ctrl`-`Alt` in vertex select mode.

A face loop can also be selected in *Vertex* select mode.
Technically `Ctrl`-`Alt`-`LMB` will select an *Edge Ring*,
however, in *Vertex* select mode, selecting an *Edge Ring* implicitly
selects a *Face Loop* since selecting opposite edges of a face implicitly selects
the entire face.
user: How do I use Attribute Domains in Blender? Include parameters, examples, warnings and best practices.

assistant: The domain of an attribute refers to what type of geometry element the attribute corresponds to.
Knowing the domain of an attribute is important because it defines how it may be interpolated and
used in nodes and shading. You can use the [Spreadsheet Editor](../../editors/spreadsheet.html)
to determine the domains of attributes.

- **Point** domain attributes are associated with single locations in space with a position:
  :   - Vertices of a mesh
      - Points of a point cloud
      - Curve control points
- **Edge** domain attributes are associated with the edges of a mesh.
- **Face** domain attributes are associated with the faces of a mesh.
- **Face Corner** domain attributes are associated with the corners of the faces of the mesh.
  An example is a UV map attribute.
- **Spline** domain attributes are associated with a group of connected
  curve control points.
- **Instance** domain attributes exist on the [Instances](instances.html) in a geometry.
  They can be used to store different values on copies of geometry data. Instance domain attributes are
  only supported in geometry nodes.
- **Layer** domain attributes are associated with a [Grease Pencil Layer](../../grease_pencil/properties/layers.html).

Attributes are automatically interpolated to other domains. For example, when the
[Position Node](geometry/read/position.html) is connected to the selection input of
the [Set Material Node](geometry/material/set_material.html) node, the values are interpolated
from the *Point* domain to the *Face* domain. Normally, domain conversions use simple averages
for values, but *Boolean* data type attributes have special rules for interpolation:

### Boolean Domain Interpolation

| From | To | Conversion |
| --- | --- | --- |
| Point | Edge | An edge is selected if both of its vertices were selected. |
| Point | Face | A face is selected if all of its vertices were selected too. |
| Point | Corner | Each corner’s value is simply a copy of the value at its vertex. |
| Point | Spline | A spline is selected if all of its control points were selected. |
|  |  |  |
| Edge | Point | A vertex is selected if any connected edge was selected. |
| Edge | Face | A face is selected if all of its edges are selected. |
| Edge | Corner | A corner is selected if its two adjacent edges were selected. |
|  |  |  |
| Face | Point | A vertex is selected if any of the connected faces were selected. |
| Face | Edge | An edge is selected if any connected face was selected. |
| Face | Corner | Each corner’s value is simply a copy of the value at its face. |
|  |  |  |
| Corner | Point | A vertex is selected if all connected face corners were selected and it is not a loose vertex. |
| Corner | Edge | An edge is selected if all corners on adjacent faces were selected. |
| Corner | Face | A face is selected if all of its corners were selected. |
|  |  |  |
| Spline | Point | Each point’s value is simply a copy of the corresponding value of the spline. |
user: What is Status Messages and how is it used in Blender Python scripting?

assistant: The middle of the Status Bar displays information about in-progress operations.

[image reference removed]

Running Task
:   Shows the progress of the currently running task (such as rendering or baking).
    Hovering the mouse pointer over the progress bar will display a time estimate.
    The task can be aborted by clicking the cancel button ().

Report Message
:   Informational messages or warnings, such as after saving a file.
    They disappear after a short time.
    Click them to show the full message in the [Info Editor](../../editors/info_editor.xhtml).
user: Show practical ways to work with Driver Settings in a Blender add-on or script – include code.

assistant: ### Type

There are two categories of drivers:

- **Built-in functions** (*Average*, *Sum*, *Min* and *Max*)

  The driven property will have the value of the average, sum, lowest or highest (respectively)
  of the values of the referenced *Driver Variables*.
  If there is only one driver variable, these functions will yield the same result.
- **Custom** (*Scripted Expression*).

  An arbitrary Python expression that can refer to the *Driver Variables* by name. See [Expressions](#expressions).

### Driver Value

The current result of the driver setup. Useful for debug purposes.

### Variables

See [Driver Variables](#driver-variables).

### Update Dependencies

Forces an update for the Driver Value dependencies.

### Show in Drivers Editor

Opens the fully featured [Drivers Editor](../../editors/drivers_editor.html).
This button only appears in the popover version of the Drivers panel.
user: Give a detailed overview of Example: syntax, arguments, return values, common patterns.

assistant: [[image reference removed]](../../../_images/modeling_modifiers_modify_normal-edit_example.jpg)

Editing custom normals to point towards a given direction
([blend-file](https://download.blender.org/ftp/mont29/persistent_data/sapling_CN.blend)).

The left tree mesh has unmodified normals, while on the right one a *Normal Edit* modifier is used to bend them
towards the camera. This shading trick is often used in games to fake scattering in trees and other vegetation.
user: Explain Clean Vertex Group Weights in complete detail according to the official Blender documentation.

assistant: Clean Vertex Group Weights unassigns vertices from
[Vertex Groups](../../../modeling/meshes/properties/vertex_groups/index.html)
whose weights are below the *Limit*. Removes weights below a given threshold.
This tool is useful for clearing your weight groups of very low (or zero) weights.

In the example shown, a cutoff value of 0.2 is used (see operator options below)
so all blue parts are cleaned out.

Note, the images use the *Show Zero weights* Active option
so that unreferenced Weights are shown in Black.

[image reference removed]

Clean example.

Subset
:   Restrict the tool to a subset.
    See above [The Subset Option](../../../sculpt_paint/weight_paint/editing.html#sculpt-paint-weight-paint-editing-subset) for how subsets are defined.

Limit
:   This is the minimum weight value that will be kept in the group.
    Weights below this value will be removed from the group.

Keep Single
:   Ensure that the *Clean Vertex Group Weights* tool will not create completely unreferenced vertices
    (which are vertices that are not assigned to any vertex group), so each vertex will
    keep at least one weight, even if it is below the limit value!
user: What is Effect Strip and how is it used in Blender Python scripting?

assistant: ### Change Effect Type

Replaces the selected effect strip with another effect type that requires the same number of inputs.

This operator preserves existing input strips and settings where possible,
making it quicker to experiment with different effects without manually recreating the setup.

For example, you can switch between effects like *Cross*, *Gamma Cross*, and *Wipe*, since they all use two inputs.

### Reassign Inputs

This tool can be used to assign (reconnect) effect strips in a different way.
Select three arbitrary strips and press `R`.
If you don’t create a cycle, those will be connected to a new effect chain.

### Swap Inputs

Swaps the first two inputs for the effect strip.
user: Provide the full official documentation entry for Keyframe Paste Offset Items, preserving all code examples.

assistant: # Keyframe Paste Offset Items

START:
:   Frame Start.

    Paste keys starting at current frame.

END:
:   Frame End.

    Paste keys ending at current frame.

RELATIVE:
:   Frame Relative.

    Paste keys relative to the current frame when copying.

NONE:
:   No Offset.

    Paste keys from original time.
user: Explain Clear Tilt in complete detail according to the official Blender documentation.

assistant: You can also reset the tilt to its default value (i.e. perpendicular to the original curve plane).
With NURBS, the tilt is always smoothly interpolated. However, with Bézier,
you can choose the [interpolation algorithm](../properties/active_spline.xhtml#bpy-types-spline-tilt-interpolation).
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [[image reference removed]](../../../_images/grease-pencil_modifiers_modify_weight-proximity_panel.png)

The Vertex Weight Proximity modifier panel.

Vertex Group
:   The vertex group to affect.

    Invert
    :   Inverts the influence of the selected vertex group. The setting reverses the weight values of the group.

Target Object
:   The object from which to compute distances.

Lowest
:   Distance mapping to 0.0 weight.

Highest
:   Distance mapping to 1.0 weight.

Minimum
:   Minimum value for vertex weight.

Multiply Weights
:   Multiply the calculated weights with the existing values in the vertex group.

### Influence

See [Influence Filters](../introduction.html#grease-pencil-modifier-influence-filters).
user: Describe Make Single User from the Blender manual or Python API, including usage steps and snippets.

assistant: Duplicates actions where necessary so that each selected strip has its own action that’s not used
by any others. This way, you can edit the keyframes in the selected strips knowing that you won’t
affect any other part of the animation.
user: Describe Move from the Blender manual or Python API, including usage steps and snippets.

assistant: # Move

In Object Mode, the move option lets you move objects.
Translation means changing location of objects. It also lets you move any elements
that make up the object within the 3D space of the active 3D Viewport.

Pressing `G` activates “Move” transformation mode. The selected object
or element then moves freely according to the mouse pointer’s location and camera.
To confirm the action, press `LMB`.
While moving items, the amount of change along the X, Y, and Z axis is displayed in the header of the 3D Viewport.

[image reference removed]

Translation Display.
user: Give a detailed overview of Stucci: syntax, arguments, return values, common patterns.

assistant: # Stucci

[image reference removed]

Stucci Texture panels.

The *Stucci* texture is based on noise functions. It is often used for stone, asphalt, or oranges,
normally for bump mapping to create grainy surfaces.