PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [[image reference removed]](../../../../../_images/movie-clip_tracking_clip_sidebar_stabilization_panel_panel.png)

2D Stabilization panel.

Anchor Frame
:   Reference point to anchor stabilization:
    other frames will be adjusted relative to this frame’s position, orientation and scale.
    You might want to select a frame number where your main subject is featured in an optimal way.

Stabilization Type
:   Rotation
    :   In addition to location, stabilizes detected rotation around the *rotation pivot point*,
        which is the weighted average of all location tracking points.

    Scale
    :   Compensates any scale changes relative to center of rotation.

Tracks for Stabilization
:   Location
    :   List of tracks to be used to compensate for camera jumps, or location movement.

    Rotation/Scale
    :   List of tracks to be used to compensate for camera tilts and scale changes.

Autoscale
:   Finds smallest scale factor which, when applied to the footage,
    would eliminate all empty black borders near the image boundaries.

    Max
    :   Limits the amount of automatic scaling.

Expected Position X/Y
:   Known relative offset of original shot, will be subtracted, e.g. for panning shots.

Expected Rotation
:   Rotation present on original shot, will be compensated, e.g. for deliberate tilting.

Expected Zoom
:   Explicitly scale resulting frame to compensate zoom of original shot.

Influence
:   The amount of transformation applied to the footage can be controlled.
    In some cases it is not necessary to fully compensate camera jumps.
    The amount of stabilization applied to the footage can be controlled.
    In some cases you may not want to fully compensate some of the camera’s jumps.
    Please note that these “\* *Influence*” parameters do control only the *compensation movements*
    calculated by the stabilizer, not the deliberate movements added through the “*Expected* \*”-parameters.

Interpolate
:   The stabilizer calculates compensation movements with sub-pixel accuracy.
    Consequently, a resulting image pixel needs to be derived from several adjacent source footage pixels.
    Unfortunately, any interpolation causes some minor degree of softening and loss of image quality.

    Nearest
    :   No interpolation, uses nearest neighboring pixel.
        This setting basically retains the original image’s sharpness.
        The downside is we also retain residual movement below the size of one pixel,
        and compensation movements are done in 1 pixel steps, which might be noticeable as irregular jumps.

    Bilinear
    :   Simple linear interpolation between adjacent pixels.

    Bicubic
    :   Highest quality interpolation, most expensive to calculate.
user: Explain Repository Management in complete detail according to the official Blender documentation.

assistant: ### Subcommand: `repo-list`

usage:

```
blender --command extension repo-list [-h]
```

List all repositories stored in Blender’s preferences.

options:
:   `-h, --help`
    :   show this help message and exit

### Subcommand: `repo-add`

usage:

```
blender --command extension repo-add [-h] [--name NAME]
                                     [--directory DIRECTORY]
                                     [--url URL]
                                     [--access-token ACCESS_TOKEN]
                                     [--source SOURCE]
                                     [--cache BOOLEAN] [--clear-all]
                                     [--no-prefs]
                                     ID
```

Add a new local or remote repository.

positional arguments:
:   ID:
    :   The repository identifier.

options:
:   `-h, --help`
    :   show this help message and exit

    `--name NAME`
    :   The name to display in the interface (optional).

    `--directory DIRECTORY`
    :   The directory where the repository stores local files (optional).
        When omitted a directory in the users directory is automatically selected.

    `--url URL`
    :   The URL, for remote repositories (optional).
        When omitted the repository is considered “local”
        as it is not connected to an external repository,
        where packages may be installed by file or managed manually.

    `--access-token ACCESS_TOKEN`
    :   The access token to use for remote repositories which require a token.

    `--source SOURCE`
    :   The type of source in (‘USER’, ‘SYSTEM’).
        System repositories are managed outside of Blender and are considered read-only.

    `--cache BOOLEAN`
    :   Use package cache (default=1).

    `--clear-all`
    :   Clear all repositories before adding, simplifies test setup.

    `--no-prefs`
    :   Treat the user-preferences as read-only,
        preventing updates for operations that would otherwise modify them.
        This means removing extensions or repositories for example, wont update the user-preferences.

### Subcommand: `repo-remove`

usage:

```
blender --command extension repo-remove [-h] [--no-prefs] ID
```

Remove a repository.

positional arguments:
:   ID:
    :   The repository identifier.

options:
:   `-h, --help`
    :   show this help message and exit

    `--no-prefs`
    :   Treat the user-preferences as read-only,
        preventing updates for operations that would otherwise modify them.
        This means removing extensions or repositories for example, wont update the user-preferences.
user: What is ShaderNodeObjectInfo(ShaderNode) and how is it used in Blender Python scripting?

assistant: # ShaderNodeObjectInfo(ShaderNode)

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

*class* bpy.types.ShaderNodeObjectInfo(*ShaderNode*)
:   Retrieve information about the object instance

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Geometry
:   The input geometry containing the hair curves whose radius will be modified.

Replace Radius
:   When enabled, the node replaces the existing radius attribute with a new one.
    When disabled, the new radius is multiplied with the existing value instead.

Radius
:   The base radius value applied to all curves when *Replace Radius* is enabled.
    This sets the overall scale of the hair thickness.

Shape
:   Defines how the radius changes along the curve.
    For example, this can create a tapered profile, with thicker roots and thinner tips.

Factor Min
:   The multiplier applied to the radius at the start (root) of each curve.
    Typically used to control how thick the curve starts.

Factor Max
:   The multiplier applied to the radius at the end (tip) of each curve.
    Typically used to control how thin the curve becomes toward the tip.
user: Give a detailed overview of BlendDataMovieClips(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # BlendDataMovieClips(bpy_struct)

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

*class* bpy.types.BlendDataMovieClips(*bpy_struct*)
:   Collection of movie clips

    tag(*value*)
    :   tag

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

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

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

    load(*filepath*, *\**, *check_existing=False*)
    :   Add a new movie clip to the main database from a file (while `check_existing` is disabled for consistency with other load functions, behavior with multiple movie-clips using the same file may incorrectly generate proxies)

        Parameters:
        :   - **filepath** (string, (never None, blend relative `//` prefix supported)) – path for the data-block
            - **check_existing** (*boolean**,* *(**optional**)*) – Using existing data-block if this file is already loaded

        Returns:
        :   New movie clip data-block

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

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

assistant: You can configure the brush main settings exposed on the Tool Settings for convenience.
For the draw brushes configuration and settings see:
[Draw Brush](../brushes/draw.xhtml).

Subdivisions
:   The number of stroke points between each stroke edge.

Thickness Profile
:   Use a [curve widget](../../../../interface/controls/templates/curve.xhtml) to define the stroke thickness
    from the start (left) to end (right) of the stroke.

    Use Curve
    :   When enabled, the stroke use a curve profile to control the thickness along the line.

### Brush Asset

Picks the brush asset used by the tool.

See [Brush Asset](../tool_settings/brushes.xhtml) for more information.

See [Draw Brushes](../brushes/draw.xhtml) for a detailed list of all draw brushes and their options.

### Brush Settings

Parameters to control to look of the stroke.

See [Draw Brushes](../brushes/draw.xhtml) for details.

### Color

Settings to determine the color of strokes.

See [Color](../tool_settings/color.xhtml)
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeIndexSwitch.index_switch_items`](bpy.types.GeometryNodeIndexSwitch.html#bpy.types.GeometryNodeIndexSwitch.index_switch_items "bpy.types.GeometryNodeIndexSwitch.index_switch_items") - [`NodeIndexSwitchItems.new`](bpy.types.NodeIndexSwitchItems.html#bpy.types.NodeIndexSwitchItems.new "bpy.types.NodeIndexSwitchItems.new") | - [`NodeIndexSwitchItems.remove`](bpy.types.NodeIndexSwitchItems.html#bpy.types.NodeIndexSwitchItems.remove "bpy.types.NodeIndexSwitchItems.remove") |
user: Provide the full official documentation entry for Attributes, preserving all code examples.

assistant: # Attributes

An *attribute* is a generic term to describe data stored per-element in a geometry data-block.
For example, every vertex can have an associated number or vector.
Attributes can be altered by connecting a value to the *Group Output* node,
but also many nodes can change the values of specific attributes.
user: Provide the full official documentation entry for Extending Menus, preserving all code examples.

assistant: When creating menus for add-ons you can’t reference menus
in Blender’s default scripts.
Instead, the add-on can add menu items to existing menus.

The function menu_draw acts like [`Menu.draw`](#bpy.types.Menu.draw "bpy.types.Menu.draw").

```
import bpy

def menu_draw(self, context):
    self.layout.operator("wm.save_homefile")

bpy.types.TOPBAR_MT_file.append(menu_draw)
```
user: Explain Object Mode List in complete detail according to the official Blender documentation.

assistant: Blender’s Modes

| Icon | Name | Details |
| --- | --- | --- |
|  | [Object Mode](../../scene_layout/object/index.xhtml) | The default mode, available for all object types. Allows editing position, rotation and scale, duplicating objects, and so on. |
|  | [Edit Mode](../../modeling/index.xhtml) | A mode for editing an object’s shape (vertices/edges/faces for meshes, control points for curves/surfaces, points/strokes for Grease Pencil, etc.). |
|  | [Sculpt Mode](../../sculpt_paint/sculpting/index.xhtml) | Provides an alternative toolset for editing an object’s shape (only for meshes). |
|  | [Vertex Paint Mode](../../sculpt_paint/vertex_paint/index.xhtml) | A mesh-only mode that allows you to set your mesh’s vertex colors (i.e. to “paint” them). |
|  | [Weight Paint Mode](../../sculpt_paint/weight_paint/index.xhtml) | A mesh-only mode, dedicated to vertex group weighting. |
|  | [Texture Paint Mode](../../sculpt_paint/texture_paint/index.xhtml) | A mesh-only mode that allows you to paint a texture directly on the model, in the 3D Viewport. |
|  | [Particle Edit Mode](../../physics/particles/mode.xhtml) | A mesh-only mode dedicated to particle systems, useful for editable systems (hair). |
|  | [Pose Mode](../../animation/armatures/posing/index.xhtml) | An armature-only mode, dedicated to posing. |
|  | [Draw Mode](../../grease_pencil/modes/draw/index.xhtml) | A Grease Pencil-only mode, dedicated to creating Grease Pencil strokes. |
|  | [Sculpt Mode (Grease Pencil)](../../grease_pencil/modes/sculpting/index.xhtml) | A Grease Pencil-only mode, used to deform and shape existing strokes more organically. |
|  | [Edit Mode (Grease Pencil)](../../grease_pencil/modes/edit/index.xhtml) | A Grease Pencil-only mode, dedicated to modifying individual strokes and points of Grease Pencil objects. |
|  | [Vertex Paint Mode (Grease Pencil)](../../grease_pencil/modes/vertex_paint/index.xhtml) | A Grease Pencil-only mode, dedicated to adding color the vertices of strokes directly. |
|  | [Weight Paint Mode (Grease Pencil)](../../grease_pencil/modes/weight_paint/index.xhtml) | A Grease Pencil-only mode, dedicated to assigning vertex weights to stroke. |

We will not go into any more detail on mode usages here,
because they are dealt with in their own sections.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`Addons.new`](bpy.types.Addons.html#bpy.types.Addons.new "bpy.types.Addons.new") - [`Addons.remove`](bpy.types.Addons.html#bpy.types.Addons.remove "bpy.types.Addons.remove") | - [`Preferences.addons`](bpy.types.Preferences.html#bpy.types.Preferences.addons "bpy.types.Preferences.addons") |
user: What is Properties and how is it used in Blender Python scripting?

assistant: Target
:   Render engine the input shaders are used for.
    By default, shaders are shared between Cycles and EEVEE –
    with multiple output nodes, a specialized shader setup can be created for each.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Geometry
:   Standard geometry input.

Selection
:   Whether or not to change the value on each point or instance.
    True values mean the value will be changed, false values mean the value will remain the same.

ID
:   The value for each element. By default, this input uses
    the [index](../read/input_index.xhtml), which is useful
    when stable IDs are desired when deleting a dynamic number of instances.
user: Show practical ways to work with LineStyleAlphaModifier_Tangent(LineStyleAlphaModifier) in a Blender add-on or script – include code.

assistant: # LineStyleAlphaModifier_Tangent(LineStyleAlphaModifier)

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

*class* bpy.types.LineStyleAlphaModifier_Tangent(*LineStyleAlphaModifier*)
:   Alpha transparency based on the direction of the stroke

    blend
    :   Specify how the modifier value is blended into the base value

        Type:
        :   enum in [`'MIX'`, `'ADD'`, `'SUBTRACT'`, `'MULTIPLY'`, `'DIVIDE'`, `'DIFFERENCE'`, `'MINIMUM'`, `'MAXIMUM'`], default `'MIX'`

    curve
    :   Curve used for the curve mapping

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

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

    invert
    :   Invert the fade-out direction of the linear mapping

        Type:
        :   boolean, default False

    mapping
    :   Select the mapping type

        - `LINEAR`
          Linear – Use linear mapping.
        - `CURVE`
          Curve – Use curve mapping.

        Type:
        :   enum in [`'LINEAR'`, `'CURVE'`], default `'LINEAR'`

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Alpha Modifier Type Items](bpy_types_enum_items/linestyle_alpha_modifier_type_items.html#rna-enum-linestyle-alpha-modifier-type-items), default `'ALONG_STROKE'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

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

assistant: Operation
:   The mathematical operator to be applied to the input values:

    Functions
    :   Add:
        :   The sum of the two values.

        Subtract:
        :   The difference between the two values.

        Multiply:
        :   The product of the two values.

        Divide:
        :   The division of the first value by the second value.

        Multiply Add:
        :   The sum of the product of the two values with *Addend*.

        Absolute:
        :   The input value is read without regard to its sign.
            This turns negative values into positive values.

        Negate:
        :   Changes the sign of the input value.

        Power:
        :   The *Base* raised to the power of *Exponent*.

    Comparison
    :   Minimum:
        :   Outputs the smallest of the input values.

        Maximum:
        :   Outputs the largest of two input values.

        Sign:
        :   Extracts the sign of the input value. All positive numbers
            will output 1. All negative numbers will output -1. And 0 will output 0.

    Rounding
    :   Divide Round:
        :   Divide the values and round the result toward zero.

        Divide Floor:
        :   Divide the values and floor the result down to the nearest integer.

        Divide Ceiling:
        :   Divide the values and ceil the result up to the nearest integer .

        Floored Modulo:
        :   Returns the positive remainder of a division operation.

        Modulo:
        :   Outputs the remainder once the first value is divided by the second value.

        Greatest Common Divisor:
        :   The largest positive integer that divides into each of the values.

        Least Common Multiple:
        :   The smallest positive integer that is divisible by both values.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

The Workbench Engine is a render engine optimized for fast rendering during modeling and animation preview.
It is not intended to be a render engine that will render final images for a project.
Its primary task is to display a scene in the 3D Viewport when it is being worked on.

By default the 3D Viewport uses Workbench to shade and light objects.
Unlike other render engines such as EEVEE or Cycles, the Workbench engine does not use shader nodes.
Instead, shading settings can be tweaked in the 3D Viewport’s [Shading popover](../../editors/3dview/display/shading.xhtml)
or the render properties when doing final renders.

Workbench supports assigning random colors to objects to make each visually distinct.
Other coloring mechanisms also exist, including; materials, Color Attributes, and textures.

Workbench also has an X-ray mode to see through objects,
along with cavity and shadow shading to help display details in objects.
Workbench supports several lighting mechanisms including studio lighting and MatCaps.

The image below is an excellent example of the Workbench engine’s capabilities
using random coloring and shadows to show the details of the model.

[image reference removed]

Workbench example.
user: How do I use CurvePoint(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CurvePoint(bpy_struct)

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

*class* bpy.types.CurvePoint(*bpy_struct*)
:   Curve control point

    index
    :   Index of this point

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

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

    radius
    :   Type:
        :   float in [-inf, inf], default 0.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: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.texture_slot`](bpy.context.html#bpy.context.texture_slot "bpy.context.texture_slot") | - [`UILayout.template_preview`](bpy.types.UILayout.html#bpy.types.UILayout.template_preview "bpy.types.UILayout.template_preview") |
user: Explain HDRIs in complete detail according to the official Blender documentation.

assistant: This panel manages [HDRI](../../glossary/index.xhtml#term-HDRI) image files
which can be used to light the view when [Material Preview](../3dview/display/shading.xhtml#dview-material-preview) or
[Rendered](../3dview/display/shading.xhtml#dview-rendered) shading is enabled.
user: How do I use GreasePencilMirrorModifier(Modifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GreasePencilMirrorModifier(Modifier)

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

*class* bpy.types.GreasePencilMirrorModifier(*Modifier*)
:   invert_layer_filter
    :   Invert layer filter

        Type:
        :   boolean, default False

    invert_layer_pass_filter
    :   Invert layer pass filter

        Type:
        :   boolean, default False

    invert_material_filter
    :   Invert material filter

        Type:
        :   boolean, default False

    invert_material_pass_filter
    :   Invert material pass filter

        Type:
        :   boolean, default False

    layer_pass_filter
    :   Layer pass filter

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

    material_filter
    :   Material used for filtering

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

    material_pass_filter
    :   Material pass

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

    object
    :   Object used as center

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

    open_influence_panel
    :   Type:
        :   boolean, default False

    tree_node_filter
    :   Layer name

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

    use_axis_x
    :   Mirror the X axis

        Type:
        :   boolean, default True

    use_axis_y
    :   Mirror the Y axis

        Type:
        :   boolean, default False

    use_axis_z
    :   Mirror the Z axis

        Type:
        :   boolean, default False

    use_layer_group_filter
    :   Filter by layer group name

        Type:
        :   boolean, default False

    use_layer_pass_filter
    :   Use layer pass filter

        Type:
        :   boolean, default False

    use_material_pass_filter
    :   Use material pass filter

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: ### Activation and Deactivation

Use `Shift`-`Ctrl`-`LMB` on any node or socket to connect it to the active viewer.

In the viewport *View* menu, the *Viewer Node* option can toggle the visibility of
all viewer visualizations, allowing you to compare the evaluated result with the final object output.

### Keyboard Shortcuts

The Viewer node system provides shortcuts to quickly assign and activate viewers:

- **Assign Shortcut** (`Ctrl`-`1`, `Ctrl`-`2`, etc.):
  Select a viewer node and press a shortcut to assign it to that number.
  The assigned number appears in the upper-right corner of the node.
- **Activate Viewer** (`1`, `2`, etc.):
  Press the assigned number key to activate the corresponding viewer node.

### Viewing Single Socket Values

In addition to using the Viewer node, single-value sockets can display their evaluated values
directly within the node editor.
When enabled, the current evaluated value is shown beside the socket input, making it easy
to inspect and debug data flow without connecting a Viewer node.

This feature is available for scalar and small data types, such as *Float*, *Integer*, *Boolean*, or *Vector* sockets.
The displayed value updates interactively as the node tree evaluates or parameters change.

### Attribute Field Visualization

When the Viewer node has both a *Geometry* and a field input connected,
the values can be visualized directly in the 3D Viewport via the
[Viewer Overlay](../../../editors/3dview/display/overlays.xhtml#dview-overlays-view-node).

The attribute’s [domain](../attributes_reference.xhtml#attribute-domains) is determined automatically when possible.
Otherwise, the Viewer defaults to the *Face Corner* domain for meshes and the *Point* domain for curves.
The domain can also be set manually from the node’s properties.

In the Spreadsheet Editor, only the columns for attributes corresponding to the currently selected domain are shown.

### Pinning

The Viewer node can be *pinned* in the Spreadsheet Editor to keep its data visible even when it becomes inactive.
When pinned, the Spreadsheet continues showing the data from the pinned Viewer node,
regardless of changes to the active object or node selection.
user: How do I use MeshStatVis(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # MeshStatVis(bpy_struct)

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

*class* bpy.types.MeshStatVis(*bpy_struct*)
:   distort_max
    :   Maximum angle to display

        Type:
        :   float in [0, 3.14159], default 0.785398

    distort_min
    :   Minimum angle to display

        Type:
        :   float in [0, 3.14159], default 0.0872665

    overhang_axis
    :   Type:
        :   enum in [Object Axis Items](bpy_types_enum_items/object_axis_items.html#rna-enum-object-axis-items), default `'NEG_Z'`

    overhang_max
    :   Maximum angle to display

        Type:
        :   float in [0, 3.14159], default 0.785398

    overhang_min
    :   Minimum angle to display

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

    sharp_max
    :   Maximum angle to display

        Type:
        :   float in [-3.14159, 3.14159], default 3.14159

    sharp_min
    :   Minimum angle to display

        Type:
        :   float in [-3.14159, 3.14159], default 1.5708

    thickness_max
    :   Maximum for measuring thickness

        Type:
        :   float in [0, 1000], default 0.1

    thickness_min
    :   Minimum for measuring thickness

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

    thickness_samples
    :   Number of samples to test per face

        Type:
        :   int in [1, 32], default 1

    type
    :   Type of data to visualize/check

        Type:
        :   enum in [`'OVERHANG'`, `'THICKNESS'`, `'INTERSECT'`, `'DISTORT'`, `'SHARP'`], default `'OVERHANG'`

    *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.MeshStatVis.type "bpy.types.MeshStatVis.type")
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: ### bpy.context

This module gives you access to the current scene,
the currently selected objects, the current object mode, and so on.

[image reference removed]

Get the current 3D Viewport mode (Object, Edit, Sculpt, etc.):

```
bpy.context.mode
```

Get the active object:

```
bpy.context.object
bpy.context.active_object
```

Change the active object’s X coordinate to 1:

```
bpy.context.object.location.x = 1
```

Move the active object by 0.5 along the X axis:

```
bpy.context.object.location.x += 0.5
```

Change all three location coordinates in one go:

```
bpy.context.object.location = (1, 2, 3)
```

Change only the X and Y coordinates:

```
bpy.context.object.location.xy = (1, 2)
```

Get the selected objects:

```
bpy.context.selected_objects
```

Get the selected objects excluding the active one:

```
[obj for obj in bpy.context.selected_objects if obj != bpy.context.object]
```

### bpy.data

Gives you access to all the data in the blend-file,
regardless of whether it’s currently active or selected.

[image reference removed]

### bpy.ops

“Operators” are actions that are normally triggered from a button or menu item
but can also be called programmatically. See the
[bpy.ops](https://docs.blender.org/api/current/bpy.ops.html)
API documentation for a list of all operators.
user: Show practical ways to work with Toggle/Enable/Disable Channel Settings in a Blender add-on or script – include code.

assistant: Toggles, enables, or disables a certain setting for the selected channels:

Protect
:   When a channel is protected (closed padlock icon), it can’t be edited.
    Instead of pressing `Shift`-`W` and selecting *Toggle*,
    you can also simply press `Tab`.

Mute
:   When a channel is muted (empty checkbox), it doesn’t affect the animation.
user: What is Node Groups and how is it used in Blender Python scripting?

assistant: # Node Groups

[image reference removed]

Example of a node group.

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

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

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

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

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

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

The *Group Output* node defines the data that is passed out of the node group.
Only sockets connected to this node will be available as outputs on the group itself.
user: Give a detailed overview of Sorting: syntax, arguments, return values, common patterns.

assistant: You can sort the order of your strokes, allowing the lines to stack in the order given.

Sort Key
:   A sort key is used to determine the stacking order of lines.

    Distance from Camera:
    :   Lines closer to the camera lie on top of further lines.

    2D Length:
    :   Longer lines lie on top of shorter lines.

    Projected X/Y:
    :   Sort by the projected X or Y value in the image coordinate system.

Integration Type
:   Use in tandem with the Sort Key to determine the range for sorting.
    Since the distance of a line from the camera may vary over vertices,
    this option computes the sort key for a line from the values computed at
    individual vertices. The value computed for the line is:

    Mean:
    :   The mean of the values obtained for the vertices.

    Min:
    :   The minimum of the values obtained for the vertices.

    Max:
    :   The maximum of the values obtained for the vertices.

    First:
    :   The value obtained for the first vertex.

    Last:
    :   The value obtained for the last vertex.

Sort Order
:   With the given result you can choose to “Reverse” the sort order.
user: Show practical ways to work with Blf in a Blender add-on or script – include code.

assistant: : the new font’s fontid or -1 if there was an error. Return type : int blf. position ( fontid , x , y , z ) ¶ Set the position for drawing text. Parameters : fontid ( int ) – The id of the typeface as returned by blf.load() , for default font use 0. x ( float ) – X axis position to draw the text. y ( float ) – Y axis position to draw the text. z ( float ) – Z axis position to draw the text. blf. rotation ( fontid , angle ) ¶ Set the text rotation angle, enable/disable using ROTATION. Parameters : fontid ( int ) – The id of the typeface as returned by blf.load() , for default font use 0. angle ( float ) – The angle for text drawing to use. blf. shadow ( fontid , level , r , g , b , a ) ¶ Shadow options, enable/disable using SHADOW . Parameters : fontid ( int ) – The id of the typeface as returned by blf.load() , for default font use 0. level ( int ) – The blur level (0, 3, 5) or outline (6). r ( float ) – Shadow color (red channel 0.0 - 1.0). g ( float ) – Shadow color (green channel 0.0 - 1.0). b ( float ) – Shadow color (blue channel 0.0 - 1.0). a ( float ) – Shadow color (alpha channel 0.0 - 1.0). blf. shadow_offset ( fontid , x , y ) ¶ Set the offset for shadow text. Parameters : fontid ( int ) – The id of the typeface as returned by blf.load() , for default font use 0. x ( float ) – Vertical shadow offset value in pixels. y ( float ) – Horizontal shadow offset value in pixels. blf. size ( fontid , size ) ¶ Set the size for drawing text. Parameters : fontid ( int ) – The id of the typeface as returned by blf.load() , for default font use 0. size ( float ) – Point size of the font. blf. unload ( filepath ) ¶ Unload an existing font. Parameters : filepath ( str | bytes ) – the filepath of the font. blf. word_wrap ( fontid , wrap_width ) ¶ Set the wrap width, enable/disable using WORD_WRAP. Parameters : fontid ( int ) – The id of the typeface as returned by blf.load() , for default font use 0. wrap_width ( int ) – The width (in pixels) to wrap words at. blf. CLIPPING ¶ Constant value 2 blf. MONOCHROME ¶ Constant value 128 blf. ROTATION ¶ Constant value 1 blf. SHADOW ¶ Constant value 4 blf. WORD_WRAP ¶ Constant value 64 Next BMesh Module (bmesh) Previous Additional Math Functions (bl_math) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page Font Drawing (blf) Hello World Text Example Drawing Text to an Image aspect() bind_imbuf() clipping() color() dimensions() disable() draw() draw_buffer() enable() load() position() rotation() shadow() shadow_offset() size() unload() word_wrap() CLIPPING MONOCHROME ROTATION SHADOW WORD_WRAP
user: Show practical ways to work with Simple in a Blender add-on or script – include code.

assistant: Size
:   A multiplier for children size.

Random Size
:   Random variation to the size of child particles.

Radius
:   The radius in which the children are distributed around their parents.
    This is 3D, so children may be emitted higher or lower than their parents.

Roundness
:   The roundness of the children around their parents. Either in a sphere (1.0) or in-plane (0.0).
user: Describe Baking Physics Simulations from the Blender manual or Python API, including usage steps and snippets.

assistant: # Baking Physics Simulations

[Baking](../glossary/index.html#term-Baking) refers to the act of storing or caching the results of a calculation.
The result of a simulation is automatically cached to memory when the animation is played,
so that the next time it runs, it can be replayed more quickly by reading the results from the memory.

If you bake the simulation the cache is protected,
and you will be unable to change the simulation settings
until you clear the baked frames by clicking *Delete Bake*.

It is generally recommended to bake your physics simulations before rendering.
Aside from no longer needing to go through the time-consuming process of simulating again,
baking can help prevent potential glitches and ensure that the outcome of the simulation
remains exactly the same every time.
user: Give a detailed overview of Polygonization: syntax, arguments, return values, common patterns.

assistant: # Polygonization

The *Polygonization* modifier simplifies strokes as much as possible
(in other words, it transforms smooth strokes into jagged polylines).

Error
:   The maximum distance allowed between the new simplified stroke and the original one
    (the larger this value is, the more jagged/approximated the resulting polylines are).
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

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

Factor
:   Controls the overall strength of the blending effect.
    A value of 0.0 applies no blending, while 1.0 fully averages the selected curves.

Blend Radius
:   Defines the distance used to find neighboring curves that influence the blend.

Blend Neighbors
:   Limits the number of neighboring curves considered during the blending process.
    Increasing this value can result in smoother results but slower performance.

Preserve Length
:   When enabled, the length of each curve is maintained during blending.
    When disabled, curves may stretch or compress as a result of the averaging.
user: Describe Source from the Blender manual or Python API, including usage steps and snippets.

assistant: Select the type of image to use. For images that come from files,
see [Supported Graphics Formats](../../files/media/image_formats.html).

### Single Image

A single, static image.

### Image Sequence

An animation where each frame is stored in a separate file.
See [Opening an Image Sequence](../../files/media/image_formats.html#image-formats-open-sequence).
For options, see [Movie](#movie) below.

### Movie

A video file. Note that if you want to do motion tracking and video compositing
rather than simply using the video as a texture, you should load it into the
[Movie Clip Editor](../clip/introduction.html) instead.

Frames
:   How many frames of the video to play. Past this point, the video will be paused
    (unless *Cyclic* is enabled).

    Match Movie Length
    :   Sets the *Frames* to the number of frames in the video file.

Start
:   Scene frame at which the video should start playing.

Offset
:   Number of frames to offset the video to an earlier point in time.
    (Put differently: how many frames at the start of the video to skip.)

Cyclic
:   Start over after the last frame to create a continuous loop.

Auto Refresh
:   Play the video in the Image Editor when the scene animation is playing.
    (The mouse cursor should be in the Image Editor or the Timeline when starting playback
    for this to work.)

Deinterlace
:   Apply deinterlacing to interlaced (analog) video.

### Generated

Image generated by Blender.

X, Y
:   The width and height of the image in pixels.

Float Buffer
:   Creates a 32-bit image. This has a larger file size,
    but holds much more color information than the standard 8-bit image.
    For close-ups and large gradients, it may be better to use a 32-bit image.

Type
:   Blank:
    :   Creates a blank image of a single specified color.

    UV Grid:
    :   Creates a checkerboard pattern with a colored cross (+) in each square.

    Color Grid:
    :   Creates a more complex colored grid with letters and numbers denoting locations.
        It could be used to check for stretching or distortion in the UV mapping.

Color
:   The fill color when creating a *Blank* image.
user: Give a detailed overview of Blender 4: syntax, arguments, return values, common patterns.

assistant: - [Blender 4.5 LTS](https://docs.blender.org/manual/en/4.5/)
- [Blender 4.4](https://docs.blender.org/manual/en/4.4/)
- [Blender 4.3](https://docs.blender.org/manual/en/4.3/)
- [Blender 4.2 LTS](https://docs.blender.org/manual/en/4.2/)
- [Blender 4.1](https://docs.blender.org/manual/en/4.1/)
- [Blender 4.0](https://docs.blender.org/manual/en/4.0/)
user: What is Join Geometry Node and how is it used in Blender Python scripting?

assistant: # Join Geometry Node

The *Join Geometry* node merges separately generated geometries into a single one.
If the geometry inputs contain different types of data, the output will also contain different data types.

[image reference removed]
user: Provide the full official documentation entry for Naming, preserving all code examples.

assistant: # Naming

You can rename your bones, either using the *Name* field in the *Bones Properties*.
It is also possible to rename by double-clicking bones in the Outliner.

Blender also provides you some tools that take advantage of bones named in a left/right
symmetry fashion, and others that automatically name the bones of an armature.
user: What is Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

Locked Track constraint.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The object or bone to point towards.

Track Axis
:   The local axis of the owner that should point at the target.
    For bones, this should typically be Y.

    A negative axis will make the owner point away from the target instead.

Locked Axis
:   The local axis of the owner that should keep its orientation.
    In other words, the only axis which the owner can rotate around.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: What is Axis Angle to Rotation Node and how is it used in Blender Python scripting?

assistant: # Axis Angle to Rotation Node

[image reference removed]

The *Axis Angle to Rotation* node converts a [axis angle](../../../../advanced/appendices/rotations.xhtml#axis-angle-mode) rotation to a standard rotation
value.
user: How do I use Extending Blender in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Add-ons

Add-ons are scripts that enable Blender to gain extra functionality;
they can be enabled from the [Preferences](../../editors/preferences/extensions.xhtml).

Outside of the Blender executable, there are hundreds of add-ons written by many people:

- Officially supported add-ons are bundled with Blender.
- Other add-ons are provided by [Blender Extensions](https://extensions.blender.org/)
  which aren’t part of official releases.
  Many of them work reliably and are very useful but are not yet ensured to be stable for release.

### Scripts

Apart from add-ons, there are several other types of scripts that extend Blender’s functionality:

Modules:
:   Utility libraries for import into other scripts.

Presets:
:   Settings for Blender’s tools and key configurations.

Startup:
:   These files are imported when starting Blender.
    They define most of Blender’s UI, as well as some additional core operators.

Custom Scripts:
:   In contrast to add-ons, they are typically intended for one-time execution via
    the [Text Editor](../../editors/text_editor.xhtml).

### Saving your own Scripts

#### File Location

All scripts are loaded from the `scripts` folder of
the [local, system and user paths](../blender_directory_layout.xhtml#blender-directory-layout).

You can setup an additional search path for scripts in
[File Paths](../../editors/preferences/file_paths.xhtml#prefs-file-paths) Preferences ‣ File Paths.

#### Installation

Add-ons are conveniently installed through Blender in the [Preferences](../../editors/preferences/extensions.xhtml).
Click the Install… button and select the `.zip` file.