PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of NodesModifierPanel(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # NodesModifierPanel(bpy_struct)

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

*class* bpy.types.NodesModifierPanel(*bpy_struct*)
:   is_open
    :   Whether the panel is expanded or closed

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

assistant: This menu demonstrates some different functions.

```
import bpy

class SubMenu(bpy.types.Menu):
    bl_idname = "OBJECT_MT_select_submenu"
    bl_label = "Select"

    def draw(self, context):
        layout = self.layout

        layout.operator("object.select_all", text="Select/Deselect All").action = 'TOGGLE'
        layout.operator("object.select_all", text="Inverse").action = 'INVERT'
        layout.operator("object.select_random", text="Random")

        # Access this operator as a sub-menu.
        layout.operator_menu_enum("object.select_by_type", "type", text="Select All by Type...")

        layout.separator()

        # Expand each operator option into this menu.
        layout.operator_enum("object.light_add", "type")

        layout.separator()

        # Use existing menu.
        layout.menu("VIEW3D_MT_transform")

bpy.utils.register_class(SubMenu)

# Test call to display immediately.
bpy.ops.wm.call_menu(name="OBJECT_MT_select_submenu")
```
user: Give a detailed overview of Attributes: syntax, arguments, return values, common patterns.

assistant: When merging attributes from multiple geometry inputs, the highest complexity data type is chosen
for the output attribute. For example, if a `weight` attribute is a Boolean on one geometry input
and a vector on another, the `weight` attribute on the output geometry will use the vector data type.
user: Explain Transparent BSDF in complete detail according to the official Blender documentation.

assistant: # Transparent BSDF

[image reference removed]

The *Transparent* BSDF
is used to add transparency without refraction, passing straight through the surface,
as if there were no geometry there. Useful with alpha maps, for example.
This shader [affects light paths somewhat differently](../../cycles/render_settings/light_paths.xhtml#render-cycles-light-paths-transparency)
than other BSDFs.
Note that only pure white transparent shaders are completely transparent.
user: Explain NodeTreeInterfaceItem(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # NodeTreeInterfaceItem(bpy_struct)

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

subclasses —
[`NodeTreeInterfacePanel`](bpy.types.NodeTreeInterfacePanel.html#bpy.types.NodeTreeInterfacePanel "bpy.types.NodeTreeInterfacePanel"), [`NodeTreeInterfaceSocket`](bpy.types.NodeTreeInterfaceSocket.html#bpy.types.NodeTreeInterfaceSocket "bpy.types.NodeTreeInterfaceSocket")

*class* bpy.types.NodeTreeInterfaceItem(*bpy_struct*)
:   Item in a node tree interface

    index
    :   Global index of the item among all items in the interface

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

    item_type
    :   Type of interface item

        Type:
        :   enum in [Node Tree Interface Item Type Items](bpy_types_enum_items/node_tree_interface_item_type_items.html#rna-enum-node-tree-interface-item-type-items), default `'PANEL'`, (readonly)

    parent
    :   Panel that contains the item

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

    position
    :   Position of the item in its parent panel

        Type:
        :   int in [-1, 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: Provide the full official documentation entry for Bpy.Ops.Object, preserving all code examples.

assistant: rtex_weight_normalize_active_vertex() vertex_weight_paste() vertex_weight_set_active() visual_geometry_to_objects() visual_transform_apply() volume_add() volume_import() voxel_remesh() voxel_size_edit()
user: How do I use Pixel Density in Blender? Include parameters, examples, warnings and best practices.

assistant: The pixel density (often called [PPI](../../../glossary/index.html#term-PPI) or [DPI](../../../glossary/index.html#term-DPI)) controls the intended physical size for an image.
This is often used for printing or the physical size when loaded into desktop publishing software.

The X/Y density is calculated using the render X/Y aspect,
making these values useful for storing the aspect ratio of non-square pixels.

The pixel-density is meta-data which doesn’t impact the quality of the image.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The Envelope modifier.

Mode
:   Deform:
    :   Replaces the original stroke with the envelope shape.

    Segments:
    :   Add segments to create the envelope shape keeping the original stroke.

    Fill:
    :   Add segments to create the envelope without the original stroke.

Spread Length
:   The number of points to skip when creating the straight segments that define the envelope.

Thickness
:   The thickness of the generated stroke segments.

Strength
:   The Opacity of the generated stroke segments.

Material Index
:   Defines the material to use on the generated stroke segments.

Skip Segments
:   The Number of generated stroke segments to skip to reduce complexity.

### Influence Filters

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Give a detailed overview of Node Map Range Items: syntax, arguments, return values, common patterns.

assistant: # Node Map Range Items

LINEAR:
:   Linear.

    Linear interpolation between From Min and From Max values.

STEPPED:
:   Stepped Linear.

    Stepped linear interpolation between From Min and From Max values.

SMOOTHSTEP:
:   Smooth Step.

    Smooth Hermite edge interpolation between From Min and From Max values.

SMOOTHERSTEP:
:   Smoother Step.

    Smoother Hermite edge interpolation between From Min and From Max values.
user: How do I use XrActionMapBindings(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # XrActionMapBindings(bpy_struct)

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

*class* bpy.types.XrActionMapBindings(*bpy_struct*)
:   Collection of XR action map bindings

    new(*name*, *replace_existing*)
    :   new

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – Name of the action map binding
            - **replace_existing** (*boolean*) – Replace Existing, Replace any existing binding with the same name

        Returns:
        :   Binding, Added action map binding

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

    new_from_binding(*binding*)
    :   new_from_binding

        Parameters:
        :   **binding** ([`XrActionMapBinding`](bpy.types.XrActionMapBinding.html#bpy.types.XrActionMapBinding "bpy.types.XrActionMapBinding"), (never None)) – Binding, Binding to use as a reference

        Returns:
        :   Binding, Added action map binding

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

    remove(*binding*)
    :   remove

        Parameters:
        :   **binding** ([`XrActionMapBinding`](bpy.types.XrActionMapBinding.html#bpy.types.XrActionMapBinding "bpy.types.XrActionMapBinding"), (never None)) – Binding

    find(*name*)
    :   find

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Binding, The action map binding with the given name

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

    *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 BlenderRNA(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # BlenderRNA(bpy_struct)

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

*class* bpy.types.BlenderRNA(*bpy_struct*)
:   Blender RNA structure definitions

    structs
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct"), (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: Explain Status Bar in complete detail according to the official Blender documentation.

assistant: # Status Bar

The Status Bar is located at the bottom of the Blender window and displays contextual information such as
keyboard shortcuts, messages, and statistical information.
The Status Bar can be hidden by disabling *Show Status Bar* in Window menu or by dragging from the top edge down.

[image reference removed]

Status Bar.
user: Give a detailed overview of Node Parts: syntax, arguments, return values, common patterns.

assistant: # Node Parts

All nodes in Blender are based on a similar construction.
This applies to [any type of node](index.xhtml#tab-node-tree-types).
These parts include the title, sockets, properties and more.

[image reference removed]
user: Describe Access Token from the Blender manual or Python API, including usage steps and snippets.

assistant: Some repositories may require authentication. The user can specify an `access token` for a repository,
which is passed along with the API request from Blender.

This is passed to the servers via an Authorization header:

```
curl -i https://extensions.blender.org/api/v1/extensions/ \
     -H "Accept: application/json" \
     -H "Authorization: Bearer abc29832befb92983423abcaef93001"
```
user: How do I use 2D Traditional Animation in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Keyframes

Traditional animation in Grease Pencil is achieved with the use of
[keyframes](../../animation/keyframes/introduction.xhtml)
that hold the strokes information at a particular frame or frame range.

With [Auto keyframe](../../animation/animation_editors.xhtml#bpy-types-toolsettings-use-keyframe-insert-auto) activated,
every time you create a stroke in Grease Pencil object Draw Mode
a new keyframe is added at the current frame on the active channel.
With Auto keyframe deactivated, you will have to add manually
a new keyframe or your new strokes will be added on the active keyframe.

See [Keyframe Editing](../../animation/keyframes/editing.xhtml) for more information.

Grease Pencil has its own mode in the Dope Sheet to work with keyframes.
See Grease Pencil mode in the [Dope Sheet](../../editors/dope_sheet/modes/grease_pencil.xhtml)
section for more information.
There are also several tools on the Stroke menu to work with keyframes and strokes.
See [Animation tools](tools.xhtml) for more information.

### Onion Skinning

One key element in traditional animation is the use of onion skinning.
Grease Pencil offer a lot of flexibility and options for this tool.
See [Onion Skinning](../properties/onion_skinning.xhtml) for more information.
user: Provide the full official documentation entry for Menus, preserving all code examples.

assistant: # Menus

Blender uses a variety of different menus for accessing options and [Operators](../../operators.xhtml).
Menus can be interacted with in the following ways:

Mouse selection
:   `LMB` on the desired item.

Numerical selection
:   You can use the number keys or numpad to input an item in the list to select.
    For example, `Numpad1` will select the first item and so on.

If a menu is too large to fit on the screen, a small
scrolling triangle appears on the top or bottom.
Scrolling is done by moving the mouse above or below this triangle.

Shortcuts

- Use `Wheel` while hovering with the mouse.
- Arrow keys can be used to navigate.
- Each menu item has an underlined character which can be pressed to activate it.
- Number keys or numpad can also be used to activate menu items.
  (`1` for the first menu item, `2` for the second etc.
  For larger menus, `Alt`-`1` activates the 11th and so on, up to `Alt`-`0` for the 20th.)
- Press `Return` to activate the selected menu item.
- Press `Esc` to close the menu without activating any menu item. This can also be
  done by moving the mouse cursor far away from the menu, or by `LMB` clicking anywhere
  outside of it.
user: Provide the full official documentation entry for Opening Images, preserving all code examples.

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

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

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

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

### Opening an Image Sequence

To load image sequence in any of the supported image file formats,
the filename of the images must contain a digit to indicate the frame order
(e.g. `*-0001.jpg`, `*-0002.jpg`, `*-0003.jpg`, etc, of any image format), indicating the frame.

The sequence could be opened by the selection of the images with any of the following methods
by the confirmation with the *Open Image* button or `Return`.

Range
:   Navigate into the directory and `LMB` click and drag over a range of names to highlight multiple files.
    You can page down and continue `Shift`-`LMB` click-dragging to add more to the selection.

Batch
:   `Shift`-`LMB` click selected non-related stills for batch processing; each image will be one frame,
    in sort order, and can be a mix of file types (`jpg`, `png`, `exr`, etc.).

All
:   Press `A` to select/deselect all files in the directory.
user: Give a detailed overview of Torso Bones: syntax, arguments, return values, common patterns.

assistant: Start by identifying on your character basic torso zones to follow as guide for bones placement.

Head, chest and pelvis are rigid zones, so they require less bones.
Having a good edge loop placement around zone boundaries on your model
will help in having correct deformation after armature binding.

[image reference removed]

Torso Landmarks.

Starting from the side view, place the main spine bones trying to use
one bone for the rigid areas and two for the flexible ones.
In addition to the main spine, the torso is provided with additional pelvis bones (to oppose the leg bending),
two breast controls and two shoulder bones.

Even if the pelvis bones will not appear in the final rig as controls, they will contribute to deformation.

[image reference removed]

Torso Bones Positioning.
user: What is FunctionNodeRotateVector(FunctionNode) and how is it used in Blender Python scripting?

assistant: # FunctionNodeRotateVector(FunctionNode)

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

*class* bpy.types.FunctionNodeRotateVector(*FunctionNode*)
:   Apply a rotation to a given vector

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

assistant: # BlendDataWorlds(bpy_struct)

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

*class* bpy.types.BlendDataWorlds(*bpy_struct*)
:   Collection of worlds

    new(*name*)
    :   Add a new world to the main database

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the data-block

        Returns:
        :   New world data-block

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

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

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

    tag(*value*)
    :   tag

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

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

assistant: Layers can store [Custom Attributes](../../modeling/geometry_nodes/attributes_reference.html).
The attributes are stored on the [Layer](../../modeling/geometry_nodes/attributes_reference.html#attribute-domains) domain.

For example, the [Layer Adjustments](layers.html#layer-adjustments) are stored as layer attributes.

Attributes
:   [List view](../../interface/controls/templates/list_view.html#ui-list-view) of all the attributes stored on the layers.

    Name
    :   Name of the layer attribute.

    Data Type
    :   The [Data Type](../../modeling/geometry_nodes/attributes_reference.html#attribute-data-types) of the attribute.
user: Give a detailed overview of Split Node: syntax, arguments, return values, common patterns.

assistant: # Split Node

[image reference removed]

The *Split* node combines two input images into a single output image,
displaying them side by side or along a rotated split line.
This is useful for comparing two versions of an image, such as before and after
a color correction, compositing effect, or render adjustment.
user: Provide the full official documentation entry for NodeFunctionFormatStringItem(bpy_struct), preserving all code examples.

assistant: # NodeFunctionFormatStringItem(bpy_struct)

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

*class* bpy.types.NodeFunctionFormatStringItem(*bpy_struct*)
:   color
    :   Color of the corresponding socket type in the node editor

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Gizmos and how is it used in Blender Python scripting?

assistant: # Gizmos

Clicking  (Show Gizmo) toggles all gizmos in the Video Sequencer.
The drop-down button displays a popover with more detailed settings,
which are described below.

Navigate
:   Enable/disable the navigation gizmo.

Active Tools
:   Enable/disable the gizmo of the active tool.
user: What is Clay Strips and how is it used in Blender Python scripting?

assistant: # Clay Strips

Similar to the [Clay](clay.html) brush,
but it uses a square tip shape instead of a round one.

Just like the *Clay* brush, it’s useful for building and removing volumes
and shapes like real clay, because it flattens details as you add/subtract from the surfaces.

Clay Strips is very commonly used for aggressive building of volumes
and deliberate control over shapes on the surface.
This brush alone can be used for a fast rough pass over the entire sculpt,
with additional smoothing or polishing often required afterwards.
This brush can be very versatile with varying stroke directions, repeated strokes
and pen pressure to achieve various results.

If used together with [Dyntopo](../tool_settings/dyntopo.html#bpy-ops-sculpt-dynamic-topology-toggle)
it’s easy to continuously build shapes, even in a single stroke.
user: Provide the full official documentation entry for Empty, preserving all code examples.

assistant: Gizmo settings for [empties](../../../modeling/empties.html).

Image
:   Show the gizmo to adjust the image size and position.

Force Field
:   Show the gizmo to adjust the [force field](../../../physics/forces/force_fields/introduction.html).
user: Describe Tool from the Blender manual or Python API, including usage steps and snippets.

assistant: Settings for the active [tool](toolbar.xhtml).

Drag
:   What to do when dragging `LMB` on a place other than the tool’s gizmo.

    Active Tool
    :   Perform the same action as when dragging the gizmo.

    Tweak
    :   Move the image under the mouse cursor.

    Select Box
    :   Drag a selection rectangle and select all the images that are partially
        or completely inside it.
user: What is Animation & Overrides and how is it used in Blender Python scripting?

assistant: Due to current design of animation data in Blender, what is editable in overrides’ animations can
change greatly depending on whether animation data was already defined in the linked reference
data-block. Animation data is created for a datablock if it gets animated by keyframes, or
through drivers.

In general, an overrides can do much more with its animation data if no animation data exists
in its linked reference data-block.

**Keyframes (a.k.a. F-Curves)**

[Keyframed animation](../../animation/keyframes/introduction.xhtml) belongs to another data-block
(an Action one). So it is possible to assign a purely local Action data-block replacing
the one linked from the library. This will completely replace the keyframed animation
from the linked data though, and not override it in any way.

Overridden Action data-blocks only support a very limited amount of editing.
For example, an existing F-Curve can be muted, but its keyframes cannot be edited,
and no new F-Curve can be added.

**Drivers**

If the linked reference data has animation data, then its overrides only have
limited possibilities to edit the existing [drivers](../../animation/drivers/introduction.xhtml).
For example, it will be possible to change the exisitng target of a driver,
but it won’t be possible to add new drivers, or new targets to an existing driver.

If the linked reference data has no animation data, then its overrides will create a new one
when they get some drivers defined. Drivers can then be fully edited, added or removed,
just as with purely local data-blocks.

**NLA**

The [NLA editor](../../editors/nla/introduction.xhtml) data also belongs to the animation data
of a data-block. However, this data does support some greater level of editing in overrides,
including moving or resizing existing strips from the linked data, and adding new local strips.
user: What is Deploying Blender in Production and how is it used in Blender Python scripting?

assistant: # Deploying Blender in Production

This page contains tips for setting up Blender in environments
such as animation studios and schools.

These environments often have special requirements regarding
security, automated deployment and customization.
user: Provide the full official documentation entry for 2D Cursor, preserving all code examples.

assistant: Just like the [3D Viewport](../3dview/3d_cursor.xhtml), the UV Editor has a Cursor
that you can jump to (View ‣ Center View to Cursor). It can also serve as
a [pivot point](../3dview/controls/pivot_point/index.xhtml) and a
[snapping target](../../modeling/meshes/uv/editing.xhtml#bpy-ops-uv-snap-selected).

To change the Cursor’s position, either press `LMB` with the Cursor tool selected,
or `Shift`-`RMB` with any tool selected. You can also change the “Location X/Y” fields
in the *View* tab of the Sidebar, in either relative coordinates (0 to 1) or
[pixel coordinates](sidebar.xhtml#bpy-types-spaceuveditor-show-pixel-coords).
In both cases, the lower left corner of the image serves as the origin (0, 0).

You can press `Shift`-`C` to move the Cursor to the center.
user: Describe Tool Context from the Blender manual or Python API, including usage steps and snippets.

assistant: These popover menus are displayed in the header when the tool context is enabled.
These properties determine where the tool is available in the user interface.

See [Supported Modes & Object Types](../modeling/geometry_nodes/tools.html#modeling-geometry-nodes-tools-contexts) for more information.

### Types

The [Object Types](../scene_layout/object/types.html) the tool supports.

Mesh
:   The node tree supports [Mesh Objects](../modeling/meshes/index.html).

Hair Curves
:   The node tree supports [Curve Objects](../modeling/curves/index.html).

Grease Pencil
:   The node tree supports [Grease Pencil Objects](../grease_pencil/index.html).

Point Cloud
:   The node tree supports [Point Cloud Objects](../modeling/point_cloud/index.html).

### Modes

The [Object Modes](3dview/modes.html) the tool supports.

Object Mode
:   The node group can be used in Object mode.

Edit Mode
:   The node group can be used in edit mode.

Sculpt Mode
:   The node group can be used in [Sculpt Mode](../sculpt_paint/sculpting/index.html).

Draw Mode Grease Pencil
:   The node group can be used in Grease Pencil [Draw Mode](../grease_pencil/modes/draw/index.html).

### Options

Wait for Click
:   Wait for a mouse click input (`LMB`) before running the operator from a menu.
    This is useful for the [Mouse Position Node](../modeling/geometry_nodes/input/scene/mouse_position.html).
user: How do I use Recalculate Handles in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Recalculate Handles* operator rotates the selected control point’s handle to be tangential to the curve.
This can be used to make curves smoother and more consistent looking.

Length
:   Recalculates the length of the handles so they are all the same length.
user: Show practical ways to work with Selecting Point Cloud Objects in a Blender add-on or script – include code.

assistant: # Selecting Point Cloud Objects

This section describes the available selection operators when working with point cloud objects in *Edit Mode*.
These operators allow you to quickly select or deselect points for further editing or transformation.
user: Show practical ways to work with NodesModifierBake(bpy_struct) in a Blender add-on or script – include code.

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: How do I use Interior in Blender? Include parameters, examples, warnings and best practices.

assistant: # Interior

By default, the edges of a soft-body mesh act like springs. This means that,
like a mechanical spring, they can stretch under tension and squeeze under pressure.
Their initial length is also their “ideal” or “rest” length, which they try to return to.

Having edges act like springs is what holds the mesh together. If you were to disable this
behavior (as well as the [Goal](../settings/goal.xhtml)), each vertex would be free
to go anywhere independently of the others, which would stretch the mesh until it’s
no longer recognizable.

Having springs along edges alone typically isn’t enough, however:
vertices in quads are still free to move towards their diagonal opposite,
potentially collapsing the quad into a line.

You could solve this by creating diagonal edges everywhere, but fortunately,
you don’t have to: simply enable the *Stiffness* option to have Blender create
diagonal springs internally. This way, you don’t have to change your mesh.

|  |  |
| --- | --- |
| ../../../_images/physics_soft-body_forces_interior_theory-1.svg   Base springs along edges. | ../../../_images/physics_soft-body_forces_interior_theory-2.svg   Additional springs when Stiffness is enabled. |

Another method of preventing mesh collapse is applying *Bending Stiffness*,
which adds rotational resistance: making edges try to keep their relative angles.

Both of these methods are described in more detail below. You can configure them,
as well as other settings, in the [Soft Body Edges panel](../settings/edges.xhtml).
user: Show practical ways to work with Multi-Object Editing in a Blender add-on or script – include code.

assistant: Edit Mode and Pose Mode let you work with multiple objects even more
easily than described above, as they can have multiple objects in the mode
at the same time.

There are two ways of accomplishing this:

- If you’re not yet in the mode, you can simply select all the objects
  and enter it.
- If you’re already in the mode, you can bring other objects into it
  by clicking `Ctrl`-`LMB` on the dot in the
  [Outliner](../outliner/introduction.html).
  Removing objects from the mode works in the same way.

Some points of note:

- The [Properties Editor](../properties_editor.html) editor will only ever show the details
  (shape keys, UV maps…) of the active object, not of all the selected ones.
- Selecting any element from an object will make it the active one.
- There are limits to the edits you can make.
  For example, you can’t create an edge that connects vertices from
  different objects.
user: How do I use ParticleSystemModifier(Modifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ParticleSystemModifier(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.ParticleSystemModifier(*Modifier*)
:   Particle system simulation modifier

    particle_system
    :   Particle System that this modifier controls

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Component
:   There are two components that can be used to control the look of the hair.
    Usually you are going to want each of these and use a [Mix Node](mix.xhtml).

    Reflection:
    :   The light that bounces off the surface of the hair.

    Transmission:
    :   The light that passes through the hair and exits on the other side.

    [image reference removed]

    With Mix node: 0 is full Reflection, 1 is full Transmission.
user: Show practical ways to work with Light Settings (EEVEE) in a Blender add-on or script – include code.

assistant: # Light Settings (EEVEE)

Besides lighting from the background and materials with emission shaders,
lights are another way to add light into the scene.
The difference is that they are not directly visible in the rendered image,
and can be more easily managed as objects of their own type.

See [Light settings](../lights/light_object.xhtml) for settings common to all renderers.
user: What is Example and how is it used in Blender Python scripting?

assistant: The example below extracts the white Suzanne monkey head from the render, colors it red, and
composites it back onto the render at an offset. Notice that the motion-blurred edges
get handled correctly (when rendering with Cycles).
Also notice that the *CryptoObject* render passes are not connected to Cryptomatte node;
this was needed with the [Cryptomatte Node (Legacy)](cryptomatte_legacy.xhtml),
but not any longer.

[image reference removed]
user: What is View and how is it used in Blender Python scripting?

assistant: ### Display

You can set the editor’s display options in this panel.

[image reference removed]

Display panel.

Aspect Ratio
:   Display aspect for this image. Does not affect rendering.

Repeat Image
:   Tile the image so it completely fills the editor.

### Annotations

Options for the annotation tool. See [Annotations](../../interface/annotate_tool.html).
user: Explain Bpy.Types.Spacenodeeditor in complete detail according to the official Blender documentation.

assistant: sed to the callback. region_type ( str ) – The region type the callback draws in; usually WINDOW . ( bpy.types.Region.type ) draw_type ( str ) – Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor. Returns : Handler that can be removed later on. Return type : object classmethod draw_handler_remove ( handler , region_type ) ¶ Remove a draw handler that was added previously. Parameters : handler ( object ) – The draw handler that should be removed. region_type ( str ) – Region type the callback was added to. Inherited Properties ¶ bpy_struct.id_data Space.type Space.show_locked_time Space.show_region_header Inherited Functions ¶ bpy_struct.as_pointer bpy_struct.driver_add bpy_struct.driver_remove bpy_struct.get bpy_struct.id_properties_clear bpy_struct.id_properties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values Space.bl_rna_get_subclass Space.bl_rna_get_subclass_py Space.draw_handler_add Space.draw_handler_remove Next SpaceNodeEditorPath(bpy_struct) Previous SpaceNLA(Space) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page SpaceNodeEditor(Space) SpaceNodeEditor SpaceNodeEditor.backdrop_channels SpaceNodeEditor.backdrop_offset SpaceNodeEditor.backdrop_zoom SpaceNodeEditor.cursor_location SpaceNodeEditor.edit_tree SpaceNodeEditor.id SpaceNodeEditor.id_from SpaceNodeEditor.insert_offset_direction SpaceNodeEditor.node_tree SpaceNodeEditor.node_tree_sub_type SpaceNodeEditor.overlay SpaceNodeEditor.path SpaceNodeEditor.pin SpaceNodeEditor.selected_node_group SpaceNodeEditor.shader_type SpaceNodeEditor.show_annotation SpaceNodeEditor.show_backdrop SpaceNodeEditor.show_gizmo SpaceNodeEditor.show_gizmo_active_node SpaceNodeEditor.show_region_asset_shelf SpaceNodeEditor.show_region_toolbar SpaceNodeEditor.show_region_ui SpaceNodeEditor.supports_previews SpaceNodeEditor.texture_type SpaceNodeEditor.tree_type SpaceNodeEditor.cursor_location_from_region() SpaceNodeEditor.bl_rna_get_subclass() SpaceNodeEditor.bl_rna_get_subclass_py() SpaceNodeEditor.draw_handler_add() SpaceNodeEditor.draw_handler_remove() Inherited Properties Inherited Functions
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

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

assistant: # Viewpoint

The menu View ‣ Viewpoint lets you align the viewing direction to
a specific axis. This can also be done using the [Navigation Gizmo](introduction.xhtml#navigation-gizmo)
or the following hotkeys:

Top:
:   `Numpad7`

Front:
:   `Numpad1`

Right:
:   `Numpad3`

Bottom:
:   `Ctrl`-`Numpad7`

Back:
:   `Ctrl`-`Numpad1`

Left:
:   `Ctrl`-`Numpad3`

The above hotkeys align the view to a global (world) axis. You can also align to a local axis
of the selected item by additionally holding `Shift`. This way, you can for example
view any mesh face head-on, no matter how it’s oriented.
(To get out of this local viewpoint, simply align to a global axis again.)

The view can also be aligned by holding `Alt`-`MMB` and dragging the mouse in a certain direction.
user: Provide the full official documentation entry for Frame Node, preserving all code examples.

assistant: # Frame Node

The *Frame* node is used to organize and group other nodes within the editor.
It helps manage complex node trees by visually grouping related nodes together.

Frames are particularly useful when the setup is too large to view easily at once,
or when you want to separate logical sections of a node tree without creating a reusable Node Group.

[image reference removed]

Example of a Frame node used to organize nodes.
user: What is Split Concave Faces and how is it used in Blender Python scripting?

assistant: Splits any selected [concave](../../../../glossary/index.xhtml#term-Concave-Face) faces so that only convex ones remain.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_cleanup_split-concave-before.png   Original mesh. | ../../../../_images/modeling_meshes_editing_mesh_cleanup_split-concave-after.png   Result of Split Concave Faces. |
user: Explain Tilt in complete detail according to the official Blender documentation.

assistant: This setting controls how the normals (visualized as arrows)
twist around each control point – so it is only relevant with 3D curves!
The tilt will be interpolated from point to point (you can check it with the normals).

[image reference removed]

30 degree Mean Tilt of all control points.
user: Explain Transform in complete detail according to the official Blender documentation.

assistant: Strokes can be edited by transforming the locations of points.

### Move, Rotate & Scale

Like other elements in Blender, points and strokes can be
moved `G`, rotated `R` or scaled `S` as described in
the [Basic Transformations](../../../scene_layout/object/editing/transform/introduction.xhtml) section.
When in *Edit Mode*,
[Proportional Editing](../../../editors/3dview/controls/proportional_editing.xhtml)
is also available for the transformation actions.

### Transform Snapping

Basic move, rotate and scale transformations for selected points/strokes.
See [Move, Rotate, Scale Basics](../../../modeling/meshes/editing/mesh/transform/basic.xhtml) for more information.

### Tools

The *Bend*, *Shear*, *To Sphere*, *Extrude* and *Shrink Fatten* transform tools are described
in the [Editing tools](tools/index.xhtml) section.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Closures define outputs that return values to the node tree in which they are evaluated.
Outputs can be created by dragging a socket from within the zone into the blank socket on the closure’s output, or by
adding sockets manually in the node’s properties.
user: Explain Install from Snap in complete detail according to the official Blender documentation.

assistant: [Snap](https://snapcraft.io/) is a universal package manager designed to work across a range of distributions.
Assuming snap is already installed, Blender can be installed through snap with:

```
snap install blender --classic
```

Installing from this method has a benefit that updates to Blender are automatically installed.
Blender from Snap should have a more consistent distribution than individual package managers.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`AssetRepresentation.metadata`](bpy.types.AssetRepresentation.html#bpy.types.AssetRepresentation.metadata "bpy.types.AssetRepresentation.metadata") - [`FileSelectEntry.asset_data`](bpy.types.FileSelectEntry.html#bpy.types.FileSelectEntry.asset_data "bpy.types.FileSelectEntry.asset_data") | - [`ID.asset_data`](bpy.types.ID.html#bpy.types.ID.asset_data "bpy.types.ID.asset_data") |