PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Calling Operators and how is it used in Blender Python scripting?

assistant: Provides Python access to calling operators, this includes operators written in
C++, Python or macros.

Only keyword arguments can be used to pass operator properties.

Operators don’t have return values as you might expect,
instead they return a set() which is made up of:
`{'RUNNING_MODAL', 'CANCELLED', 'FINISHED', 'PASS_THROUGH'}`.
Common return values are `{'FINISHED'}` and `{'CANCELLED'}`, the latter
meaning that the operator execution was aborted without making any changes or
saving an undo history entry.

If operator was cancelled but there wasn’t any reports from it with `{'ERROR'}` type,
it will just return `{'CANCELLED'}` without raising any exceptions.
However, if there are error reports, a `RuntimeError` will be raised
after the operator finishes execution, including all error report messages,
regardless of the return status (even if it was `{'FINISHED'}`).

Calling an operator in the wrong context will raise a `RuntimeError`,
there is a poll() method to avoid this problem.

Note that the operator ID (bl_idname) in this example is `mesh.subdivide`,
`bpy.ops` is just the access path for Python.

### Keywords and Positional Arguments

For calling operators keywords are used for operator properties and
positional arguments are used to define how the operator is called.

There are 2 optional positional arguments (documented in detail below).

```
bpy.ops.test.operator(execution_context, undo)
```

- execution_context - `str` (enum).
- undo - `bool` type.

Each of these arguments is optional, but must be given in the order above.

```
import bpy

# Calling an operator.
bpy.ops.mesh.subdivide(number_cuts=3, smoothness=0.5)

# Check poll() to avoid exception.
if bpy.ops.object.mode_set.poll():
    bpy.ops.object.mode_set(mode='EDIT')
```
user: Describe StripModifiers(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # StripModifiers(bpy_struct)

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

*class* bpy.types.StripModifiers(*bpy_struct*)
:   Collection of strip modifiers

    active
    :   The active strip modifier in the list

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

    new(*name*, *type*)
    :   Add a new modifier

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – New name for the modifier
            - **type** (enum in [Strip Modifier Type Items](bpy_types_enum_items/strip_modifier_type_items.html#rna-enum-strip-modifier-type-items)) – Modifier type to add

        Returns:
        :   Newly created modifier

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

    remove(*modifier*)
    :   Remove an existing modifier from the strip

        Parameters:
        :   **modifier** ([`StripModifier`](bpy.types.StripModifier.html#bpy.types.StripModifier "bpy.types.StripModifier"), (never None)) – Modifier to remove

    clear()
    :   Remove all modifiers from the strip

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: otLight.shadow_filter_radius SpotLight.shadow_jitter_overblur SpotLight.shadow_maximum_resolution SpotLight.shadow_soft_size SpotLight.show_cone SpotLight.spot_blend SpotLight.spot_size SpotLight.use_absolute_resolution SpotLight.use_shadow_jitter SpotLight.use_soft_falloff SpotLight.use_square SpotLight.inline_shader_nodes() SpotLight.bl_rna_get_subclass() SpotLight.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Give a detailed overview of Mirror: syntax, arguments, return values, common patterns.

assistant: The *Mirror Vertex Group* tool mirrors the weights
from one side of a perfectly symmetrical mesh to the opposite side.
Those vertices that have no corresponding vertex on the other side will not be affected.
But note, the weights are not transferred to the corresponding opposite bone weight group.

[image reference removed]

Mirror example.

Mirror Weights
:   With this option checked, every selected vertex receives
    the weight information of its symmetrical counterpart.
    If both vertices are selected, it will be a weight information exchange;
    if only one is selected, information from the unselected will overwrite the selected one.
    Information on weight is passed for the active group only,
    unless *All Groups* is checked, in which case it is passed for all groups.

Flip Group Names
:   Works with selected vertices that belong to vertex groups with “symmetrical names”
    (with components like “L”, “R”, “right”, “left”).
    All selected vertices that belong to the active group, or to the symmetrical of the active group,
    will have their assignation to that group replaced by an assignation to the symmetrical one;
    however, its weight will be preserved.
    If *All Groups* is checked, all assignations to these kind of groups
    will be replaced by the symmetrical counterpart, also keeping the old weights.

All Groups
:   Operate on all vertex groups, instead of the active one.

Topology Mirror
:   Mirror for meshes which are not fully symmetric (approximate mirror).
    See [here](../../modeling/meshes/tools/tool_settings.html#bpy-types-mesh-use-mirror-topology) for more information.
user: Describe Creating a Force Field from the Blender manual or Python API, including usage steps and snippets.

assistant: To create a single force field,
you can select Add ‣ Force Field and select the desired force field.
This method creates an empty with the force field attached.

Examples of an empty with the force field attached.

|  |  |  |
| --- | --- | --- |
| ../../../_images/physics_forces_force-fields_types_vortex_visualzation.png   Vortex: force field. | ../../../_images/physics_forces_force-fields_types_wind_visualzation.png   Wind: force field. | ../../../_images/physics_forces_force-fields_types_force_visualzation.png   Force: force field. |

To create a field from an existing object you have to select the object and
change to the *Physics* tab. Select the field type in the *Fields* menu.
user: Describe Q from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [**Quad**](glossary/index.xhtml#term-Quad) - [**Quadrangle**](glossary/index.xhtml#term-Quadrangle) | - [**Quadrilateral**](glossary/index.xhtml#term-Quadrilateral) - [**Quaternion**](glossary/index.xhtml#term-Quaternion) - [**Quaternion Rotation**](glossary/index.xhtml#term-Quaternion-Rotation) |
user: How do I use ThemeOutliner(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ThemeOutliner(bpy_struct)

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

*class* bpy.types.ThemeOutliner(*bpy_struct*)
:   Theme settings for the Outliner

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

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

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

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

    row_alternate
    :   Overlay color on every other row

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

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

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

    space
    :   Settings for space

        Type:
        :   [`ThemeSpaceGeneric`](bpy.types.ThemeSpaceGeneric.html#bpy.types.ThemeSpaceGeneric "bpy.types.ThemeSpaceGeneric"), (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: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_vertex_rip-vertices_before.png   Selected vertex. | ../../../../_images/modeling_meshes_editing_vertex_rip-vertices_after.png   Hole created after using rip on vertex. |
| ../../../../_images/modeling_meshes_editing_vertex_rip-vertices_edges-before.png   Edges selected. | ../../../../_images/modeling_meshes_editing_vertex_rip-vertices_edges-after.png   Result of rip with edge selection. |
| ../../../../_images/modeling_meshes_editing_vertex_rip-vertices_complexselection-before.png   A complex selection of vertices. | ../../../../_images/modeling_meshes_editing_vertex_rip-vertices_complexselection-after.png   Result of rip operation. |
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Image/Color
:   Standard color input.

Factor
:   Controls the amount of influence the node exerts on the image.

Black Level Compositor Only
:   Defines the input color that should be mapped to black.

White Level Compositor Only
:   Defines the input color that should be mapped to white.
user: Provide the full official documentation entry for Properties, preserving all code examples.

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

assistant: # TextureNodeValToRGB(TextureNode)

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"), [`TextureNode`](bpy.types.TextureNode.html#bpy.types.TextureNode "bpy.types.TextureNode")

*class* bpy.types.TextureNodeValToRGB(*TextureNode*)
:   color_ramp
    :   Type:
        :   [`ColorRamp`](bpy.types.ColorRamp.html#bpy.types.ColorRamp "bpy.types.ColorRamp"), (readonly)

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

assistant: Default Fade
:   Automatically calculates a linear fade over the length of the strip.

    Effect Fader
    :   Allows you to manually [keyframe](../../../../../animation/keyframes/index.xhtml) a custom fade.
        This can be used with different [easings](../../../../../editors/graph_editor/fcurves/properties.xhtml#editors-graph-fcurves-settings-easing)
        to fine-tune the fade in/out.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`DynamicPaintModifier.canvas_settings`](bpy.types.DynamicPaintModifier.html#bpy.types.DynamicPaintModifier.canvas_settings "bpy.types.DynamicPaintModifier.canvas_settings") |  |
user: Provide the full official documentation entry for Workspaces, preserving all code examples.

assistant: # Workspaces

Workspaces are essentially predefined window layouts.
Each Workspace consists of a set of [Areas](areas.xhtml)
containing [Editors](../../editors/index.xhtml), and is geared towards a specific task such as
modeling, animating, or scripting. You’ll typically switch between
multiple Workspaces while working on a project.

[image reference removed]

Workspaces are located at the Topbar.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Outer Mask
:   A mask representing the outside shape, which will fade from black at its edges
    to white at the *Inner Mask*.

Inner Mask
:   A mask representing the inside shape, which will be fully white.

Images Edges
:   The edges of the image that intersects the outer mask will be considered edges
    of the outer mask. Otherwise, the outer mask will be considered open-ended.

    |  |  |
    | --- | --- |
    | ../../../_images/compositing_types_matte_double-edge-mask_in.png   Disabled. | ../../../_images/compositing_types_matte_double-edge-mask_bleed.png   Enabled. |

Only Inside Outer
:   Only edges of the inner mask that lie inside the outer mask will be considered.
    Otherwise, all edges of the inner mask will be considered.

    |  |  |
    | --- | --- |
    | ../../../_images/compositing_types_matte_double-edge-mask_all.png   Disabled. | ../../../_images/compositing_types_matte_double-edge-mask_adjacent.png   Enabled. |
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Grid
:   The input signed distance field to be smoothed.

Width
:   The radius of the smoothing kernel in voxels.
    Larger values result in a broader smoothing effect, producing softer,
    less detailed surfaces. Smaller values restrict smoothing to immediate
    neighbors, retaining more fine detail.

Iterations
:   The number of times the mean filter is applied.
    Each iteration increases the smoothness of the surface.
    Multiple passes can approximate a Gaussian-like blur effect.
user: Provide the full official documentation entry for Advanced, preserving all code examples.

assistant: Brush Type
:   Defines the basic behavior and the available settings. Through the settings of
    a brush type, brushes can be created that produce vastly different effects.

    The *Essentials* asset library contains brushes for each of the brush types. Their preview image
    and description should give a good idea of the effect the brush produces, with the particular
    combination of brush type and settings. Because of this, they are usually the more useful starting
    point for custom brushes than the mere brush type is, which is why the brush type is part of the
    *Advanced* brush settings.

    Brushes and Brush Types of each mode:

    - [Sculpt](../sculpting/brushes/brushes.xhtml)
    - [Vertex Paint](../vertex_paint/brushes.xhtml)
    - [Weight Paint](../weight_paint/brushes.xhtml)
    - [Texture Paint](../texture_paint/brushes.xhtml)

Accumulate
:   Causes stroke dabs to accumulate on top of each other.

Front Faces Only
:   When enabled, the brush only affects vertices that are facing the viewer.

Affect Alpha 2D Painting Only
:   When this is disabled, it prevents changes to the alpha channel while painting (Only in 3D Viewport).

Anti-Aliasing 2D Painting Only
:   Toggles [Anti-Aliasing](../../glossary/index.xhtml#term-Anti-Aliasing) around the brush,
    this is useful if you are working with pixel art or low resolution textures.

Auto-Masking Sculpt Mode
:   The auto-masking toggles in the brush settings are the same as the sculpt mode auto-masking settings.
    The difference is that these toggles can be customized per brush to create specific brush behaviors.

Sculpt Plane Sculpt Mode
:   Use this menu to set the plane in which the sculpting takes place.
    In other words, the primary direction that the vertices will move.

    Area Plane:
    :   The movement takes place in the direction of average normal for all active vertices within the brush area.
        Essentially, this means that the direction is dependent on the surface beneath the brush.

    View Plane:
    :   Sculpting in the plane of the current 3D Viewport.

    X, Y, Z Plane:
    :   The movement takes place in the positive direction of one of the global axes.

Original Sculpt Mode
:   Normal
    :   When locked it keeps using the normal of the surface where stroke was initiated,
        instead of the surface normal currently under the cursor.

    Plane
    :   When locked keep using the plane origin of surface where stroke was initiated,
        instead of the surface plane currently under the cursor.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Index
:   Determines which of the following input sockets is passed through to the output.
    The index is zero-based (i.e., the first input corresponds to index 0).

Each socket represents a possible input to select from.
The active input is determined by the *Index* value.

Additional input sockets can be added by either:
- Dragging a connection onto the empty socket at the bottom of the list.
- Clicking the  icon in the node header.
user: Explain Adding Nodes in complete detail according to the official Blender documentation.

assistant: Nodes are added via the *Add* menu in the editor’s header or using a keyboard shortcut.

Nodes can also be added by dragging a connection from an existing node’s input or output socket
and dropping the connection above an empty space instead of connecting to another socket.
This action will open a search menu with a list of compatible nodes
and their sockets that can be added and connected to the existing node.
Confirming the menu selection will add the node which can then be moved and placed.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Vertex Index
:   The index of the vertex for which to find the corners.

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

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

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

assistant: # Set Mesh Normal Node

[image reference removed]

The *Set Mesh Normal* node stores a normal vector for each mesh element.

This can be used to control shading appearance and influence subsequent operations that rely on surface normals.
user: Describe ShaderNodeValue(ShaderNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShaderNodeValue(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.ShaderNodeValue(*ShaderNode*)
:   Input numerical values to other nodes in the tree

    *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 GeometryNodeImportVDB(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeImportVDB(GeometryNode)

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

*class* bpy.types.GeometryNodeImportVDB(*GeometryNode*)
:   Import volume data from a .vdb file

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

assistant: [image reference removed]

Rim Visual Effect.

Rim Color
:   Defines the rim light color.

Mask Color
:   Defines a color to keep unaltered.

Blend Mode
:   The mask blending operation to perform. See [Color Blend Modes](../../glossary/index.xhtml#term-Color-Blend-Modes).

Offset X, Y
:   Control the color mask displacement in pixels on the X and Y axis.

### Blur

Blur X, Y
:   Control the blur scale in pixels on the X and Y axis.

Samples
:   Number of blur samples (0 disabled the blur effect).
user: How do I use NodeSocketVectorAcceleration(NodeSocketStandard) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeSocketVectorAcceleration(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorAcceleration(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe IndexSwitchItem(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # IndexSwitchItem(bpy_struct)

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

*class* bpy.types.IndexSwitchItem(*bpy_struct*)
:   identifier
    :   Consistent identifier used for the item

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Persistent Data
:   Keep render data in memory after rendering for faster re-renders and animation renders
    at the cost of extra memory usage while performing other tasks in Blender.

    When using multiple [View Layers](../../layers/view_layer.xhtml),
    only data from a single view layer is preserved to keep memory usage within bounds;
    however, objects shared between view layers are preserved.
user: Provide the full official documentation entry for Color Palette, preserving all code examples.

assistant: # Color Palette

[image reference removed]

Color Palette.

Color Palettes are a way of storing a brush’s color so that it can be used at a later time.
This is useful when working with several colors at once.

Palette
:   A [Data-Block Menu](data_block.html#ui-data-block) to select a palette.

(New Pallet Color)
:   Adds the current brush’s primary *Color* to the palette.

(Delete Pallet Color)
:   Removes the currently selected color from the palette.

/ (Move Pallet Color)
:   Moves the selected color up/down one position.

(Sort By)
:   Sort Colors by Hue, Saturation, Value, Luminance.

Color List
:   Each color that belongs to the palette is presented in a list.
    Clicking on a color will change the brush’s primary *Color* to that color.
user: How do I use Edit Mode Tools in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| `Ctrl`-`E` | [Extrude](../../modeling/meshes/editing/mesh/extrude.xhtml) |
| `Ctrl`-`B` | [Bevel](../../modeling/meshes/editing/edge/bevel.xhtml) |
| `I` | [Inset](../../modeling/meshes/editing/face/inset_faces.xhtml) |
| `K` | [Knife](../../modeling/meshes/editing/mesh/knife_topology_tool.xhtml) |
| `Alt`-`C` | [Loop Cut](../../modeling/meshes/editing/edge/loopcut_slide.xhtml) |
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`DynamicPaintModifier.brush_settings`](bpy.types.DynamicPaintModifier.html#bpy.types.DynamicPaintModifier.brush_settings "bpy.types.DynamicPaintModifier.brush_settings") |  |
user: Give a detailed overview of Make Vertex Parent: syntax, arguments, return values, common patterns.

assistant: # Make Vertex Parent

Creates a parent-child relationship between the active object and selected vertex or triangle from the edited mesh.

This operator is used to make the active object follow a vertex (or triangle of vertices) on the edited mesh,
so that when the vertex moves, the child object follows.
This is particularly useful for attaching objects to deforming geometry,
such as having an accessory follow a character mesh during animation.
user: Explain GreasePencilLayerGroup(GreasePencilTreeNode) in complete detail according to the official Blender documentation.

assistant: # GreasePencilLayerGroup(GreasePencilTreeNode)

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

*class* bpy.types.GreasePencilLayerGroup(*GreasePencilTreeNode*)
:   Group of Grease Pencil layers

    color_tag
    :   Type:
        :   enum in [`'NONE'`, `'COLOR1'`, `'COLOR2'`, `'COLOR3'`, `'COLOR4'`, `'COLOR5'`, `'COLOR6'`, `'COLOR7'`, `'COLOR8'`], default `'COLOR1'`

    is_expanded
    :   The layer group is expanded in the UI

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Sphere Projection in complete detail according to the official Blender documentation.

assistant: Projects the selected faces onto a virtual sphere, then flattens that sphere
much like a world map: the latitude lines vertical and the longitude lines
evenly spaced. This is useful for texturing spherical shapes such as eyes or planets.

The sphere is centered on the [Transform Pivot Point](../../../editors/3dview/controls/pivot_point/index.xhtml),
which is normally the averaged-out position of the selected faces; however, you
can also move it to a different place using e.g. the [3D Cursor](../../../editors/3dview/3d_cursor.xhtml).

[image reference removed]

Using an equirectangular image with a Sphere Projection.

### Options

The [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel allows fine control over how the mesh is unwrapped:

Direction, Align
:   The direction of the sphere’s vertical axis.

    View on Equator
    :   Use an axis that’s perpendicular to the viewing direction in the 3D Viewport.
        If *Align* is *Polar ZX*, use the vertical axis of the viewing plane;
        if it’s *Polar ZY*, use the horizontal one.

    View on Poles
    :   Use an axis that’s parallel to the viewing direction in the 3D Viewport.
        Depending on *Align*, the sphere will be rotated by 90° around its vertical axis
        and the UV map will be shifted horizontally by a quarter.

    Align to Object
    :   Use the object’s local Z axis.
        Depending on *Align*, the sphere will be rotated by 90° around its vertical axis
        and the UV map will be shifted horizontally by a quarter.

Pole
:   How to handle vertices that lie on the sphere’s vertical axis.
    (See [Cylinder Projection](#bpy-ops-uv-cylinder-project) for an example.)

    Pinch
    :   Place all UV versions of the vertex at the same U coordinate.
        This tends to result in heavily distorted UV faces.

    Fan
    :   Place each UV version of the vertex at a U coordinate that minimizes distortion.

Preserve Seams
:   Cut the mesh along its seams before projecting.

Correct Aspect
:   Adjusts the UV mapping to account for the aspect ratio of the image associated with the material.
    This ensures that UVs are scaled correctly when unwrapping onto non-square textures.

    For this option to work, the mesh must have a material with an
    [Image Texture node](../../../render/shader_nodes/textures/image.xhtml), and this node must be selected in the
    [Shader Editor](../../../editors/shader_editor.xhtml).

Clip to Bounds
:   Moves any out-of-bounds UVs to the nearest border.

Scale to Bounds
:   Stretches the resulting UV map to fill the complete texture.
user: Describe NodeClosureInputItem(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeClosureInputItem(bpy_struct)

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

*class* bpy.types.NodeClosureInputItem(*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'`

    structure_type
    :   What kind of higher order types are expected to flow through this socket

        Type:
        :   enum in [Node Socket Structure Type Items](bpy_types_enum_items/node_socket_structure_type_items.html#rna-enum-node-socket-structure-type-items), default `'AUTO'`

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Storyboarding in complete detail according to the official Blender documentation.

assistant: # Storyboarding

Storyboarding in Blender provides a flexible way to plan, visualize, and iterate on shots before production begins.
It combines 2D drawing, 3D layout, and video editing tools into a single, non-destructive workflow.

Using Blender, artists can create storyboards directly inside the same environment used for layout, animation, and
rendering. This allows early creative decisions about composition, timing, and camera movement to remain consistent
throughout production.

A typical storyboarding setup in Blender involves:

- **Multiple Scenes:** Each scene represents an individual shot or camera setup, keeping assets and timelines organized.
- **Grease Pencil Drawings:** Used to sketch story panels directly in 3D space or over cameras for quick visual blocking.
- **Video Sequence Editor:** Combines scene strips, sound, and timing adjustments into a complete sequence.
- **Linked Assets:** Enables reuse of characters, props, and sets across multiple scenes, ensuring visual consistency.
- **Asset Libraries and Overrides:** Provide a structured way to manage shared resources across a production.

This workflow bridges the gap between 2D storyboarding and 3D previsualization, supporting both traditional drawn
storyboards and 3D layout boards (often called “3D animatics”). It scales from solo projects to collaborative pipelines,
where multiple artists contribute to shots, layout, and editorial in parallel.

Blender’s integrated design means that storyboards, timing edits, and scene data remain connected. Changes to a camera,
pose, or Grease Pencil drawing automatically update in the edit—streamlining revisions and enabling rapid iteration
from concept to final animation.
user: What is Video and how is it used in Blender Python scripting?

assistant: Strobe
:   Display every nth frame.
    For example, if you set this to 10, the strip will only display frames 1, 11, 21, 31, 41… of the source.

    It is important to realize that this property is a float value.
    This allows you to strobe effect synced exactly to a beat.

Reverse Frames
:   Plays the strip backwards starting from the last frame in the sequence.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

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: Provide the full official documentation entry for TextLine(bpy_struct), preserving all code examples.

assistant: # TextLine(bpy_struct)

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

*class* bpy.types.TextLine(*bpy_struct*)
:   Line of text in a Text data-block

    body
    :   Text in the line

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Derivative of [limbs.paw](#limbs-paw) with extended IK suitable for use in rear paws.
The additional IK tries to maintain thigh and paw bones (1st and 3rd) in a nearly parallel orientation
as the main IK control moves and rotates.

For best results, thigh and paw bones should start nearly parallel in the rest pose.
user: Give a detailed overview of Transformation Constraint: syntax, arguments, return values, common patterns.

assistant: # Transformation Constraint

This constraint is more complex and versatile than the other “transform” constraints.
It lets you set the location, rotation or scale of an object/bone based on the
location, rotation or scale of another, mixing and matching axes as you see fit.
An example could be to set a gear’s X rotation based on the Y coordinate of
a rail next to it.

The constraint works with input and output value ranges, one for each axis.
It first clamps the input value to the *Map From* range, then offsets and scales it
to the corresponding *Map To* range. This lets you, say, map a Y coordinate
in the range (-3m, 3m) to an X rotation in the range (0, 180°).
user: What is Properties and how is it used in Blender Python scripting?

assistant: Clamp Type
:   Method to clamp.

    Min Max:
    :   Constrain values between Min and Max.

    Range:
    :   Constrain values between Min and Max. When Min is greater than Max,
        constrain between Max and Min instead.
user: Show practical ways to work with Installing Python in a Blender add-on or script – include code.

assistant: 1. Download the [Python installation package](https://www.python.org/downloads/) for Windows. In this guide version
   3.9.x is used.
2. Install Python with the installation wizard. Please make sure that you enable the “Add Python to PATH” option:

   [image reference removed]

   The option must be enabled so you can build the manual with the make script.

   All other settings can remain as set by default.
user: Describe Symmetry from the Blender manual or Python API, including usage steps and snippets.

assistant: # Symmetry

Mirror Vertex Groups
:   Use this option for mirrored painting on groups that have symmetrical names,
    like with suffix “.R”/ “.L” or “_R” / “_L”. If a group has no mirrored counterpart,
    it will paint symmetrically on the active group itself.
    You can read more about the naming convention in
    [Editing Armatures: Naming conventions](../../../animation/armatures/bones/editing/naming.xhtml#armature-editing-naming-conventions).
    The conventions for armatures/bones apply here as well.

Mirror X, Y, Z
:   Mirror the brush strokes across the selected local axes.
    Note that if you want to alter the directions the axes point in,
    you must rotate the model in Edit Mode and not in Object Mode.

Radial X, Y, Z
:   These settings allow for radial symmetry in the desired axes.
    The number determines how many times the stroke will be repeated
    within 360 degrees around the central axes.

Topology Mirror
:   Use topology-based mirroring, for when both sides of a mesh have matching mirrored topology.
    See [here](../../../modeling/meshes/tools/tool_settings.xhtml#bpy-types-mesh-use-mirror-topology) for more information.
user: Show practical ways to work with Split Edges Node in a Blender add-on or script – include code.

assistant: # Split Edges Node

[image reference removed]

Like the [Edge Split Modifier](../../../modifiers/generate/edge_split.xhtml), the *Split Edges* node splits and duplicates edges
within a mesh, breaking ‘links’ between faces around those split edges.
user: Give a detailed overview of Bake Channels: syntax, arguments, return values, common patterns.

assistant: Generates new keyframes for the selected curves.

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

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

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

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

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

    If disabled, the new keyframes are based on the original curve, and the modifiers stay applied.
user: What is Mirror and how is it used in Blender Python scripting?

assistant: UVs can be mirrored on the Y axis or the X axis:

- Mirror X
- Mirror Y

You can also use the hotkeys `X` or `Y`,
or hold the `MMB` and drag in the mirror direction.

### Copy Mirrored UV Coordinates

Copies UVs from one side of the mirrored mesh to the other.
Affects only selected vertices (on both sides).

Axis Direction
:   Positive/Negative

Precision
:   Tolerance for finding vertex duplicates.
user: Describe Drivers from the Blender manual or Python API, including usage steps and snippets.

assistant: Upgrading to the latest graphics drivers often solves problems. Newer drivers have bug fixes that help Blender
function correctly.

On macOS, graphics drivers are built into the operating system and the only way to get newer drivers is to upgrade
macOS as a whole to the latest version.
user: Describe CurveProfilePoints(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CurveProfilePoints(bpy_struct)

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

*class* bpy.types.CurveProfilePoints(*bpy_struct*)
:   Collection of Profile Points

    add(*x*, *y*)
    :   Add point to the profile

        Parameters:
        :   - **x** (*float in* *[**-inf**,* *inf**]*) – X Position, X Position for new point
            - **y** (*float in* *[**-inf**,* *inf**]*) – Y Position, Y Position for new point

        Returns:
        :   New point

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

    remove(*point*)
    :   Delete point from the profile

        Parameters:
        :   **point** ([`CurveProfilePoint`](bpy.types.CurveProfilePoint.html#bpy.types.CurveProfilePoint "bpy.types.CurveProfilePoint"), (never None)) – Point to remove

    *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 Select More/Less and how is it used in Blender Python scripting?

assistant: The purpose of these operators is to reduce or enlarge the current selection within a stroke
(i.e. they will never “go outside” of a stroke or “jump” to another stroke in the same object).

More
:   For each selected point, select *all* its linked points (i.e. one or two…).

Less
:   For each selected point, if *all* points linked to this point are selected, keep this one selected.
    Otherwise, deselect it.
user: What is Example and how is it used in Blender Python scripting?

assistant: [image reference removed]

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

The left tree mesh has unmodified normals, while on the right one a *Normal Edit* modifier is used to bend them
towards the camera. This shading trick is often used in games to fake scattering in trees and other vegetation.