PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with ObjectSolverConstraint(Constraint) in a Blender add-on or script – include code.

assistant: # ObjectSolverConstraint(Constraint)

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

*class* bpy.types.ObjectSolverConstraint(*Constraint*)
:   Lock motion to the reconstructed object movement

    camera
    :   Camera to which motion is parented (if empty active scene camera is used)

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

    clip
    :   Movie Clip to get tracking data from

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

    object
    :   Movie tracking object to follow

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

    set_inverse_pending
    :   Set to true to request recalculation of the inverse matrix

        Type:
        :   boolean, default False

    use_active_clip
    :   Use active clip defined in 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: Describe Deactivation from the Blender manual or Python API, including usage steps and snippets.

assistant: Enable deactivation of resting rigid bodies. Allows the object to be deactivated during the simulation
(improves the performance and stability, but can cause glitches).

Start Deactivated
:   The rigid body starts deactivated. It will be activated when in proximity of
    moving active rigid body objects. The proximity check uses the object’s
    bounding box to determine if a moving object is close enough to activate it.

Linear Velocity
:   Specifies the linear deactivation velocity below which the rigid body
    is deactivated and the simulation stops simulating the object.

Angular Velocity
:   Specifies the angular deactivation velocity below which the rigid body
    is deactivated and the simulation stops simulating the object.
user: Provide the full official documentation entry for Delete, preserving all code examples.

assistant: Options for the *Delete* pop-up menu:

Vertices
:   This will delete the selected control points, *without* breaking the curve
    (i.e. the adjacent points will be directly linked, joined, once the intermediary ones are deleted).
    Remember that NURBS order cannot be higher than its number of control points,
    so it might decrease when you delete some control point.
    Of course, when only one point remains, there is no more visible curve,
    and when all points are deleted, the curve itself is deleted.

Segment
:   Deletes the segment that connects the selected control points and disconnecting them.

### Dissolve Vertices

Deletes the selected control points, while the remaining segment
is fitted to the deleted curve by adjusting its handles.

|  |  |
| --- | --- |
| ../../../_images/modeling_curves_editing_curve_make-segment.png   Before deleting. | ../../../_images/modeling_curves_editing_curve_delete-vertices.png   Deleting vertices. |
| ../../../_images/modeling_curves_editing_curve_delete-segment.png   Deleting segment. | ../../../_images/modeling_curves_editing_curve_dissolve-vertices.png   Dissolve vertices. |
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Space
:   Object Space maps work for static meshes, and will render slightly faster with less memory usage.
    Tangent Space maps can be used for meshes that will be deformed, like animated characters,
    so the displacement follows the deformation.
user: Provide the full official documentation entry for ACES, preserving all code examples.

assistant: The standard Blender configuration includes essential support for
[ACES](https://www.oscars.org/science-technology/sci-tech-projects/aces) workflows
with the ACEScg working space, ACES 2.0 view transform and OpenEXR images saved in
the ACES2065-1 and ACEScg color spaces.

This covers most needs for working in an ACES pipeline. However for more complete
support, the
[official ACES configurations](https://github.com/AcademySoftwareFoundation/OpenColorIO-Config-ACES/releases)
can be manually installed and set through the `OCIO` environment variable.
user: How do I use Time in Blender? Include parameters, examples, warnings and best practices.

assistant: The Time panel is used to control source and timeline position of the strip.

Lock (padlock icon in panel header)
:   Prevents the strip from being moved.

Show Retiming Keys
:   Toggle visibility and selectability of [Retiming Keys](../../../../video_editing/edit/montage/editing.xhtml#sequencer-editing-retiming).

Channel
:   Changes the channel number, or row, of the strip.

Start
:   Changes the starting frame of the strip, which is the same as selecting and moving the strip.

Duration
:   Changes the length (in frames) of the strip. This works by changing the end frame,
    which is the same as selecting and moving the strip’s right handle.

End
:   Shows the ending time and frame of the strip.

Strip Offset Start/End
:   Positive values will move the strip’s handles inwards, making it start later than the start
    of the source material and stop before its end. This lets you trim down the source material
    to the part you need. You can enable the
    [Offsets overlay](../display.xhtml#bpy-types-sequencertimelineoverlay-show-strip-offset)
    to see the start and end of the full source file.

    Negative values will move the strip’s handles outwards, making it start earlier than the start
    of the source material and stop after its end. This lets you show the first and/or last frame
    as a frozen image for some time.

    Instead of adjusting these offsets in the Sidebar, you can also drag the strip’s handles.

Hold Offset Start/End
:   Used for trimming frames off the start/end of the source material. At first sight, this
    does the same as the *Strip Offset* properties, but you can in fact combine them
    to hold (freeze) a frame other than the first or last one. For example, if you set the
    *Hold Offset Start* to 10 and the *Strip Offset Start* to -20, the video will first show
    the 11th frame of the source for 21 frames, and then play the remaining frames.

Current Frame
:   The Playhead’s frame number relative to the start of the strip.
user: What is Gamma Node and how is it used in Blender Python scripting?

assistant: # Gamma Node

[image reference removed]

Use this node to apply a gamma correction. The node is typically used to convert from gamma encoded to linear
color space, or in the reverse direction with 1/gamma.
user: How do I use Viewport Gizmos in Blender? Include parameters, examples, warnings and best practices.

assistant: Navigate
:   Enable/disable the [navigation gizmo](../navigate/introduction.xhtml#navigation-gizmo).

Active Tool
:   Enable/disable the gizmo of the active tool.

Active Object
:   Enable/disable the Object Gizmos for the active element (see below).
user: What is Library Linking and how is it used in Blender Python scripting?

assistant: When linking a rig into another file, you generally want to create a collection that includes
the generated rig and the character mesh. You do not need to include the meta-rig or the widget
object collection. You then link in the collection and run
[Make Library Override](../../../files/linked_libraries/library_overrides.html#bpy-ops-object-make-override-library).

The `rig_ui_template.py` text data-block responsible for the rig UI
will be automatically linked along with the rig, you don’t need to link it separately.
However, the script will not run until you run it manually from the Text editor or save and restart Blender.
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Geometry
:   The resulting geometry with clumped hair curves.

### Guide Map

Guide Index
:   The guide index map used for this operation.
    If a new guide map was generated by this node, it is stored and provided through this output
    for reuse in subsequent operations.
user: Explain Markers in complete detail according to the official Blender documentation.

assistant: # Markers

Markers are used to denote frames with key points or significant events within an animation.
E.g. it could be that a character’s animation starts, the camera changes position, or a door opens.
Markers can be given names to make them more meaningful at a quick glance.
They are available in many of Blender’s editors.

Markers can be created and edited in the following editors:

- [Graph Editor](../editors/graph_editor/introduction.xhtml)
- [Dope Sheet](../editors/dope_sheet/introduction.xhtml)
- [NLA Editor](../editors/nla/index.xhtml)
- [Video Sequence Editor](../video_editing/index.xhtml)
user: Describe Make Segment from the Blender manual or Python API, including usage steps and snippets.

assistant: While this operator sounds like it creates a single segment (grid line) between two control points,
it’s really more similar to [Bridge Edge Loops](../../meshes/editing/edge/bridge_edge_loops.html#bpy-ops-mesh-bridge-edge-loops) for meshes: it bridges the gap
between two disjoint surfaces by creating as many new segments as necessary. Simply select a border
row (or column) in each surface, then press `F` to connect those borders.

Note that the two surfaces need to be part of the same Surface object. If you have two separate
objects, these first need to be combined into one using [Join](../../../scene_layout/object/editing/join.html).
Also, the borders to connect must have the same number of control points.

### Example

The images below show bridging of two “surfaces” consisting of just a curve, but it’s also possible to
connect sheets.

|  |  |
| --- | --- |
| ../../../_images/modeling_surfaces_editing_control-points_joining-ready.png   Before bridging. | ../../../_images/modeling_surfaces_editing_control-points_joining-complete.png   After bridging. |
user: Show practical ways to work with Pie Menus in a Blender add-on or script – include code.

assistant: A pie menu is a menu whose items are spread radially around the mouse.

[image reference removed]

The 3D Viewport Mode Pie menu.

Releasing the key without moving the mouse will keep the menu open so you
can click the desired item.
If you do move the mouse before releasing, the item closest to the mouse
will be activated instantly.

An open disc widget at the center of the pie menu shows
the current direction of the pie menu. The selected item is also highlighted.
A pie menu will only have a valid direction for item selection
if the mouse is touching or extending beyond the disc widget at the center of the menu.

Pie menu items support key accelerators, which are the letters underlined on each menu item.
Number keys can also be used.

If there are sub-pies available, it is indicated by a plus icon.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Mesh
:   Standard geometry input.

Selection
:   A boolean field indicating which elements should be extruded.

Offset
:   The translation vector for each extruded element. By default, this is the element’s
    [normal](../../geometry/read/normal.html).

Offset Scale
:   Scaling factor for the above translation vector.

Individual Face Mode Only
:   Whether to extrude each face individually rather than extruding connected groups of faces together.
user: Show practical ways to work with Data Access (bpy.data) in a Blender add-on or script – include code.

assistant: # Data Access (bpy.data)

This module is used for all Blender/Python access.

bpy.data.data
:   Access to Blender’s internal data

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

```
import bpy

# Print all objects.
for obj in bpy.data.objects:
    print(obj.name)

# Print all scene names in a list.
print(bpy.data.scenes.keys())

# Remove mesh Cube.
if "Cube" in bpy.data.meshes:
    mesh = bpy.data.meshes["Cube"]
    print("removing mesh", mesh)
    bpy.data.meshes.remove(mesh)

# Write images into a file next to the blend.
import os
with open(os.path.splitext(bpy.data.filepath)[0] + ".txt", 'w') as fs:
    for image in bpy.data.images:
        fs.write("{:s} {:d} x {:d}\n".format(image.filepath, image.size[0], image.size[1]))
```
user: What is Playback Controls and how is it used in Blender Python scripting?

assistant: The Playback Controls region contains controls and options
related to playback, keying, auto keyframing, and transport.

These settings allow you to:

- Control how animations are previewed and synchronized with audio.
- Insert and manage keyframes through keying sets and auto keying.
- Navigate the timeline using playback and transport controls.
- Adjust frame ranges and preview specific segments of the animation.

Sync Scene Time
:   Set the active scene and time based on the current scene strip.
    See the [workspace settings](../../../interface/window_system/workspaces.html#bpy-types-workspace-use-scene-time-sync).
user: Describe Tool Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: Depth
:   The initial depth (from the screen into the scene) used when placing the object.

    Surface:
    :   Start placing on the surface under the mouse cursor. If there is no surface, this does the
        same as *Cursor Plane*.

    Cursor Plane:
    :   Start placing on a plane that goes through the [3D Cursor](../3d_cursor.html)
        and is aligned according to the *Orientation* and *Plane Axis*.

    Cursor View:
    :   Start placing on a plane that goes through the 3D Cursor and is aligned to the view.

Orientation
:   The new object’s orientation – a set of three axes, out of which *Plane Axis* chooses one.

    Surface:
    :   The object uses the normal orientation of the surface under the mouse cursor.
        If there is no surface, this does the same as *Default*.

    Default:
    :   The object uses the default [Transform Orientation](../controls/orientation.html).

Snap To
:   The target to use while [Snapping](../controls/snapping.html).

    Geometry:
    :   Snap to all types of geometry (vertices, edges, and faces).

    Default:
    :   Snap to the target defined in the global snapping options.

Plane Axis
:   Which of the three *Orientation* axes (X, Y or Z) is “up” for the object.
    The object’s base will be perpendicular to this axis.

Auto Axis
:   Rather than using the *Orientation* axis indicated by *Plane Axis*,
    use the one that’s closest to the viewport’s viewing direction
    (when not hovering over a surface).

Base

Origin
:   How the base is defined.

    Edge:
    :   The base is defined from one corner to the opposing corner.

    Center:
    :   The base is defined from the centerpoint to a corner.

Aspect
:   Whether the base has a free or fixed aspect ratio.

    Free:
    :   The width and depth of the base can be chosen independently.

    Fixed:
    :   The width and depth of the base are forced to be equal.

Height

Origin
:   How the height is defined.

    Edge:
    :   The base becomes the bottom, after which you define the top.

    Center:
    :   The base becomes the center, after which you define the top.

Aspect
:   Whether the side of the bounding box has a free or fixed aspect ratio.

    Free:
    :   The height can be chosen independently of the base.

    Fixed:
    :   The height is forced to be equal to the largest side of the base.

Segments
:   Number of vertical segments. Like the Earth’s meridians, going pole to pole.

Rings
:   Number of horizontal segments. These are like the Earth’s parallels.
user: How do I use Example in Blender? Include parameters, examples, warnings and best practices.

assistant: [[image reference removed]](../../../_images/modeling_modifiers_deform_cast_example.jpg)

Top: Suzanne without modifiers. Middle: Suzanne with each type of Cast Modifier (Sphere, Cylinder and Cuboid).
Bottom: Same as above, but now only X axis is enabled.
[Sample blend-file](https://archive.blender.org/wiki/2015/index.php/File:263-Cast-Modifier.blend).
user: Show practical ways to work with Grease Pencil Materials in a Blender add-on or script – include code.

assistant: # Grease Pencil Materials

Materials control the appearance of the Grease Pencil object.
They define the base color and texture of the strokes and filled areas.

There is always only one active material in the list (the selected one).
When you draw, the new strokes use the active material.

You can override the base material color using the tools in
[Vertex Mode](../modes/vertex_paint/introduction.html)
or the Draw and Tint tool in Draw Mode.

The material always remains linked to the strokes, this means that any change in a material will change
the look of already drawn strokes.

[image reference removed]

Same stroke linked to different materials.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`XrActionMap.actionmap_items`](bpy.types.XrActionMap.html#bpy.types.XrActionMap.actionmap_items "bpy.types.XrActionMap.actionmap_items") - [`XrActionMapItems.find`](bpy.types.XrActionMapItems.html#bpy.types.XrActionMapItems.find "bpy.types.XrActionMapItems.find") - [`XrActionMapItems.new`](bpy.types.XrActionMapItems.html#bpy.types.XrActionMapItems.new "bpy.types.XrActionMapItems.new") - [`XrActionMapItems.new_from_item`](bpy.types.XrActionMapItems.html#bpy.types.XrActionMapItems.new_from_item "bpy.types.XrActionMapItems.new_from_item") | - [`XrActionMapItems.new_from_item`](bpy.types.XrActionMapItems.html#bpy.types.XrActionMapItems.new_from_item "bpy.types.XrActionMapItems.new_from_item") - [`XrActionMapItems.remove`](bpy.types.XrActionMapItems.html#bpy.types.XrActionMapItems.remove "bpy.types.XrActionMapItems.remove") - [`XrSessionState.action_binding_create`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.action_binding_create "bpy.types.XrSessionState.action_binding_create") - [`XrSessionState.action_create`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.action_create "bpy.types.XrSessionState.action_create") |
user: Explain Shader AOV in complete detail according to the official Blender documentation.

assistant: Shader AOVs (Arbitrary Output Variables) are custom render passes that can hold additional
information for use in compositing. Create a pass in the *Shader AOV* panel,
write to it from a material using the [AOV Output Node](../shader_nodes/output/aov.html),
and finally read from it in the Compositor using the socket on the Render Layers node.

Name
:   The name of the render pass. Used in both the AOV Output node and the
    Render Layers node. The name can be anything as long as it doesn’t conflict
    with other (enabled) passes.

Data Type
:   The type of data that the render pass stores per pixel.
    Use *Color* to store a color, normal, or other type of vector.
    Use *Value* to store a single number.
user: Describe CompositorNodeBoxMask(CompositorNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CompositorNodeBoxMask(CompositorNode)

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

*class* bpy.types.CompositorNodeBoxMask(*CompositorNode*)
:   Create rectangular mask suitable for use as a simple matte

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The *Toolbar* contains a set of tools that can be used in the node editor.

[Select](../../selecting.xhtml#tool-select-tweak)
:   Select or move nodes and links.

    [Select Box](../../selecting.xhtml#tool-select-box)
    :   Select nodes or links by dragging a box around them.

    [Select Circle](../../selecting.xhtml#tool-select-circle)
    :   Select nodes or links by clicking or dragging with a circular brush.

    [Select Lasso](../../selecting.xhtml#tool-select-lasso)
    :   Select nodes or links by drawing a free-form lasso.

[Annotate](../../annotate_tool.xhtml#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../annotate_tool.xhtml#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../annotate_tool.xhtml#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../annotate_tool.xhtml#tool-annotate-eraser)
    :   Erase previous drawn annotations.

Link Cuts
:   Delete connections between nodes by drawing a line across the links.
    See [Cut Links](editing.xhtml#bpy-ops-node-links-cut) for more information.

Mute Links
:   Mute connections between nodes by drawing a line across the links.
    Muted links are kept in place but ignored in evaluation.
    See [Mute Links](editing.xhtml#bpy-ops-node-links-mute) for more information.

Add Reroute
:   Insert a [Reroute Node](types/layout/reroute.xhtml)
    point on links by drawing a line across them.
    Reroute nodes help organize complex node trees by redirecting connections.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Data Type
:   Map Range supports both Float and Vector data types. Changing the data type will
    also update the sockets to reflect the data type chosen.

Interpolation Type
:   The mathematical method used to transition between gaps in the numerical inputs.

    Linear:
    :   Linear interpolation between From Min and From Max values.

    Stepped Linear:
    :   Stepped linear interpolation between From Min and From Max values.

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

    Smoother Step:
    :   Smoother Hermite edge interpolation between From Min and From Max values.

Clamp
:   If enabled, the output is clamped to the target range.
user: Explain Inputs in complete detail according to the official Blender documentation.

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

Width
:   The radius of the median filter kernel, measured in voxels.
    Larger widths produce stronger smoothing by considering a wider
    neighborhood around each voxel.

Iterations
:   The number of times the median filter is applied.
    Multiple iterations increase smoothing and noise reduction while
    maintaining edge sharpness.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Start/End Frame
:   Start frame and End frame of the range of time specifying the values
    the output should last. This range becomes the X axis of the graph.
    The time input could be reversed by specifying a start frame greater than the end frame.
user: Describe RenderView(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # RenderView(bpy_struct)

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

*class* bpy.types.RenderView(*bpy_struct*)
:   name
    :   Type:
        :   string, default “”, (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: Explain NodeSocketVector2D(NodeSocketStandard) in complete detail according to the official Blender documentation.

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

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 2 items in [-inf, inf], default (0.0, 0.0)

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Drag & Dropping to 3D Viewport, preserving all code examples.

assistant: Dragging an object from the Outliner to the [3D Viewport](../3dview/index.xhtml)
creates a [duplicate](../../scene_layout/object/editing/duplicate.xhtml) – a new object with its own copy
of the underlying object data.

Dragging object data from the Outliner to the 3D Viewport creates a
[linked duplicate](../../scene_layout/object/editing/duplicate_linked.xhtml) – a new object that references
the same underlying object data.
user: Describe Manage Brushes from the Blender manual or Python API, including usage steps and snippets.

assistant: # Manage Brushes

Brush assets are stored in [asset libraries](../../files/asset_libraries/introduction.html) to make them accessible from
any Blender session. There are two ways of managing brush assets:

- Using [asset operators](#brush-management-utility-operators): Create and update brush assets
  using utility operators from any Blender file. Storage is managed by Blender. Convenient for
  simple “on the fly” management of personal brush
  asset libraries.
- Using [manual storage](#brush-management-manual): Create and update brush assets by opening
  blend files within asset libraries, and managing brush asset data-blocks in there. Useful for
  careful curation of asset libraries, especially to prepare them for sharing with others.
user: What is ShaderNodeVolumeInfo(ShaderNode) and how is it used in Blender Python scripting?

assistant: # ShaderNodeVolumeInfo(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.ShaderNodeVolumeInfo(*ShaderNode*)
:   Read volume data attributes from volume grids

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The *Target* is the object which the constraint should refer to.
For example, the [Copy Location Constraint](../transform/copy_location.xhtml) copies the location of the
target object to the constrained object.

Initially, the *Target* is empty and the constraint’s icon is red, indicating it’s inactive:

[image reference removed]

Once a target is selected, the icon will turn gray and the constraint will start working.

By default, the constraint uses the location of the target’s [Origin](../../../glossary/index.xhtml#term-Object-Origin),
but if the target is a [Mesh](../../../glossary/index.xhtml#term-Mesh) or [Lattice](../../../glossary/index.xhtml#term-Lattice), it’s possible to change this by
selecting a [Vertex Group](../../../glossary/index.xhtml#term-Vertex-Group). The constraint will then use the weighted average of
the target’s vertex positions.

[image reference removed]

Alternatively, if the target is an [Armature](../../../glossary/index.xhtml#term-Armature), it’s possible to select a [Bone](../../../glossary/index.xhtml#term-Bone)
and choose an interpolated position between its [Head](../../../glossary/index.xhtml#term-Head) and [Tail](../../../glossary/index.xhtml#term-Tail).
The  button enables following the curved shape of
[Bendy Bones](../../armatures/bones/properties/bendy_bones.xhtml).

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

assistant: Image
:   Standard color input.

Key Color
:   The color that is to be keyed.

Color Space
:   It is also possible to work with YCbCr color space,
    but only the Cb and Cr channels are taken into consideration
    for determining the distance between the foreground and background pixels.

    RGB, YCC

Tolerance
:   A threshold what the node considers a match between the key color and the foreground pixel.
    The tolerance affects how close a pixel needs to be to the background pixel
    to be considered an absolute match.

Falloff
:   When the Falloff value is high, pixels that are close to the Key Color are more
    transparent than pixels that are not as close to the Key Color
    (but still considered close enough to be keyed).
    When the Falloff value is low, it does not matter how close
    the pixel color (Image) is to the Key Color, it is transparent.
user: Show practical ways to work with Inherited Properties in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`Strip.name`](bpy.types.Strip.html#bpy.types.Strip.name "bpy.types.Strip.name") - [`Strip.type`](bpy.types.Strip.html#bpy.types.Strip.type "bpy.types.Strip.type") - [`Strip.select`](bpy.types.Strip.html#bpy.types.Strip.select "bpy.types.Strip.select") - [`Strip.select_left_handle`](bpy.types.Strip.html#bpy.types.Strip.select_left_handle "bpy.types.Strip.select_left_handle") - [`Strip.select_right_handle`](bpy.types.Strip.html#bpy.types.Strip.select_right_handle "bpy.types.Strip.select_right_handle") - [`Strip.mute`](bpy.types.Strip.html#bpy.types.Strip.mute "bpy.types.Strip.mute") - [`Strip.lock`](bpy.types.Strip.html#bpy.types.Strip.lock "bpy.types.Strip.lock") - [`Strip.frame_final_duration`](bpy.types.Strip.html#bpy.types.Strip.frame_final_duration "bpy.types.Strip.frame_final_duration") - [`Strip.frame_duration`](bpy.types.Strip.html#bpy.types.Strip.frame_duration "bpy.types.Strip.frame_duration") - [`Strip.frame_start`](bpy.types.Strip.html#bpy.types.Strip.frame_start "bpy.types.Strip.frame_start") - [`Strip.frame_final_start`](bpy.types.Strip.html#bpy.types.Strip.frame_final_start "bpy.types.Strip.frame_final_start") | - [`Strip.frame_final_end`](bpy.types.Strip.html#bpy.types.Strip.frame_final_end "bpy.types.Strip.frame_final_end") - [`Strip.frame_offset_start`](bpy.types.Strip.html#bpy.types.Strip.frame_offset_start "bpy.types.Strip.frame_offset_start") - [`Strip.frame_offset_end`](bpy.types.Strip.html#bpy.types.Strip.frame_offset_end "bpy.types.Strip.frame_offset_end") - [`Strip.channel`](bpy.types.Strip.html#bpy.types.Strip.channel "bpy.types.Strip.channel") - [`Strip.use_linear_modifiers`](bpy.types.Strip.html#bpy.types.Strip.use_linear_modifiers "bpy.types.Strip.use_linear_modifiers") - [`Strip.blend_type`](bpy.types.Strip.html#bpy.types.Strip.blend_type "bpy.types.Strip.blend_type") - [`Strip.blend_alpha`](bpy.types.Strip.html#bpy.types.Strip.blend_alpha "bpy.types.Strip.blend_alpha") - [`Strip.effect_fader`](bpy.types.Strip.html#bpy.types.Strip.effect_fader "bpy.types.Strip.effect_fader") - [`Strip.use_default_fade`](bpy.types.Strip.html#bpy.types.Strip.use_default_fade "bpy.types.Strip.use_default_fade") - [`Strip.color_tag`](bpy.types.Strip.html#bpy.types.Strip.color_tag "bpy.types.Strip.color_tag") - [`Strip.modifiers`](bpy.types.Strip.html#bpy.types.Strip.modifiers "bpy.types.Strip.modifiers") - [`Strip.show_retiming_keys`](bpy.types.Strip.html#bpy.types.Strip.show_retiming_keys "bpy.types.Strip.show_retiming_keys") |
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Object
:   Specific object to use for object space coordinates.
    This only affects the *Object* output.

From Instancer Cycles Only
:   If the object is generated by instancing from vertices or faces, use texture coordinates from instancer.
    This only affects the *Generated* and *UV* outputs.

    [image reference removed]

    From left to right: Sphere with a UV-mapped texture.
    Small spheres instanced to the faces of the textured sphere using
    [instancing from faces](../../../scene_layout/object/properties/instancing/faces.xhtml).
    Small spheres with *From Instancer* enabled, using the UV map of the large sphere.
user: How do I use Brushes in Blender? Include parameters, examples, warnings and best practices.

assistant: # Brushes

This is a list of all provided ‘Essentials’ brush assets that come with Blender.
These are based on various [Brush Types](../../brush/brush_settings.xhtml#sculpt-tool-settings-brush-type) which are mentioned for each brush..
user: Give a detailed overview of limbs.spline_tentacle: syntax, arguments, return values, common patterns.

assistant: This rig type implements a flexible tentacle with an IK system using the Spline IK constraint. The control bones
define control points of a Bezier curve, and the bone chain follows the curve.

The curve control points are sorted into three groups: start, middle and end. The middle controls are always
visible and active, while the other two types can be shown and hidden dynamically using properties; when enabled
they appear next to the corresponding permanent start/end control and can be moved from there.

Extra Start Controls
:   Specifies the number of optional start controls to generate.

Middle Controls
:   Specifies the number of middle controls to generate.

Extra End Controls
:   Specifies the number of optional end controls to generate.

Tip Control:
:   Specifies how the curve stretching and the final control bone work:

    Stretch To Fit
    :   Stretches the whole bone chain to fit the length of the curve defined by the controls.

        An end twist control is generated to control the twist along the chain.

    Direct Tip Control
    :   Generates an IK end control, which directly controls the final bone of the chain similar to how
        regular IK works for limbs, as well as controlling the end of the bezier curve. The middle bones of
        the chain stretch to follow the curve and cover the gap.

        The rig automatically deduces twist of up to 180 degrees based on the orientation of the end control.
        Higher amounts of twist have to be dialed in through an End Twist Estimate slider to avoid flipping.

    Manual Squash & Stretch
    :   This mode allows full manual control over the chain scaling, while the chain covers as much of the curve
        as it can given its current length.

        The start control of the chain manages its uniform squash & stretch scale, while the end twist control
        manages both the twist of the chain, as well as its scale at the tip (blended gradually along the length).

Radius Scaling
:   Allows scaling the controls to control the thickness of the chain through the curve.

Maximum Radius
:   Specifies the maximum scale allowed by the Radius Scaling feature.

FK Controls
:   Generates an FK control chain and IK-FK snapping.

Assign FK Layers
:   If enabled, allows placing the FK chain in different bone collections from the IK bones.
user: How do I use NodeTreeInterfaceSocketObject(NodeTreeInterfaceSocket) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeTreeInterfaceSocketObject(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketObject(*NodeTreeInterfaceSocket*)
:   Object socket of a node

    default_value
    :   Input value used for unconnected socket

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Blender is available for download on Windows, macOS, and Linux. Always check that your graphics drivers are up to date
and that OpenGL is properly supported. Blender has a set of [minimum and recommended requirements](https://www.blender.org/download/requirements/); so make sure these are met before trying to install Blender.

Support for other hardware such as graphic tablets and 3D mice are covered later in
[Configuring Hardware](../configuration/hardware.html).
user: What is Properties and how is it used in Blender Python scripting?

assistant: From, To
:   The color space of the input image and the color space to convert it to.

    The list of color spaces depends on the active [OCIO config](../../../render/color_management/opencolorio.html#ocio-config).
    The default supported color spaces are described in detail here:
    [Default OpenColorIO Configuration](../../../render/color_management/color_spaces.html#ocio-config-default-color-spaces)
user: Explain Curve Info in complete detail according to the official Blender documentation.

assistant: # Curve Info

The *Curve Info* node provides per-curve attributes describing the identity,
geometry, and relationships of each curve in a hair or curve system.
It is often used in procedural grooming and deformation setups to drive
randomization, orientation, or effects that depend on each curve’s properties.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Mode
:   Rectangle:
    :   Generate a rectangle-shaped curve with a width and a height.

    Parallelogram:
    :   Generate a rectangle with an offset for the different X values of the top and bottom edges.

    Trapezoid:
    :   Generate a trapezoid-shaped curve with a height, a width for the top and bottom, and an offset.

    Kite:
    :   Generate a kite shape with a width, and the top and bottom points distance from the X axis.

    Points:
    :   Generate a four point cyclic poly spline by inputting the position vectors directly.
user: What is Merge by Distance and how is it used in Blender Python scripting?

assistant: Merges the selected vertices that are closer to each other than a certain distance.

Merge Distance
:   Vertices closer than this distance will be merged.

Unselected
:   Allow merging selected vertices with unselected ones.

Sharp Edges
:   Mark edges as [sharp](../edge/edge_data.xhtml#bpy-ops-mesh-mark-sharp) if they have split
    [custom normals](../../structure.xhtml#modeling-meshes-normals-custom).
user: Show practical ways to work with With Envelope Weights in a Blender add-on or script – include code.

assistant: Works in a similar way to *With Automatic Weights*. The difference is that the influences are calculated
based on the [Bone Envelopes](../bones/properties/deform.xhtml#armature-bones-envelope) settings.
It will assign a weight to each vertex group the vertices that is inside its bone’s influence volume,
depending on their distance to this bone.

This means newly included/excluded vertices or new envelope settings will not be taken into account.
You will have to apply Armature Deform With Envelope Weights parenting again.

[image reference removed]

Two sets of armatures, each with three bones.
user: How do I use Outline in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Outline* operator converts selected Grease Pencil strokes into closed perimeter shapes.
It creates new strokes around the outer boundary of the original stroke,
effectively generating a filled outline with adjustable thickness.

View
:   Defines the projection method used to generate the outline:

    View:
    :   Use the current viewport perspective as the projection plane.

    Front:
    :   Use the X-Z axes as the projection plane (front view).

    Side:
    :   Use the Y-Z axes as the projection plane (side view).

    Top:
    :   Use the X-Y axes as the projection plane (top view).

    Camera:
    :   Use the active camera’s perspective as the projection plane.

Radius
:   Sets the thickness of the outline on both sides of the original stroke.
    Higher values result in a wider perimeter.

Offset Factor
:   Scales the stroke outline inward or outward.
    - Positive values push the perimeter outward.
    - Negative values pull it inward.
    - A value of 0 centers the perimeter on the original stroke.

Corner Subdivisions
:   Number of subdivisions used to smooth corners at stroke endpoints and joints.
    Higher values result in smoother corners but increase stroke complexity.

|  |  |
| --- | --- |
| <../../../_images/grease-pencil_modes_edit_stroke-menu_outline-1.png>   Original stroke. | <../../../_images/grease-pencil_modes_edit_stroke-menu_outline-2.png>   Stroke after applying the *Outline* operator. |
user: Give a detailed overview of Examples: syntax, arguments, return values, common patterns.

assistant: Fig. [Meta ball base.](#fig-meta-ball-base) shows the *base* meta labeled “B”.
The other two *Meta* objects are *children*. Children’s selection rings are always black,
while the group’s mesh is orange. Because the metas are grouped,
they form a unified mesh which can always be selected by selecting the mesh of any meta in the group.

[image reference removed]

Meta ball base.

For example, in Fig. [Meta ball base.](#fig-meta-ball-base), only the lower sphere (the parent) has been selected,
and you see that both the parent’s mesh *and* all of the children’s meshes are now highlighted.

[image reference removed]

Scaling the “base”.

The *base* meta object controls the *polygonalization* (mesh structure) for the group, and
as such, also controls the polygonalization for the children (non-base) metas.
If we transform the *base* meta, the children’s polygonalization changes.
However, if we transform the children, the polygonalization remains unchanged.