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

assistant: # Introduction

The Dope Sheet offers a bird’s-eye view of the keyframes inside the scene.
It’s inspired by classical hand-drawn animation, where animators make use of a chart
showing exactly when each drawing, sound, and camera move will occur, and for how long.
It is also possible to show [Playback Controls](../../animation/animation_editors.xhtml#animation-editors-footer) to control the playhead.

[image reference removed]

The Dope Sheet.
user: Provide the full official documentation entry for Header, preserving all code examples.

assistant: Shader Type
:   The type of data whose shader nodes are being edited:

    Object:
    :   Edit shader nodes for the active object’s [Material](../render/materials/index.html).

    World:
    :   Edit shader nodes for the [World background](../render/lights/world.html).

    Line Style:
    :   Edit shader nodes for Freestyle [Line Styles](../render/freestyle/view_layer/line_style/index.html)

Use Nodes Line Style
:   Use shader nodes to define the texture for the freestyle line style.

Slot
:   The *Slot* menu can be used to select
    the active [material slot](../render/materials/assignment.html#bpy-types-materialslot) on the active object.
    The material selector to the right of it can change the material that is in the selected slot.

/ Pinned
:   Keeps the current material selection visible in the Shader editor
    even when another object or material is selected elsewhere.
user: Give a detailed overview of Metadata: syntax, arguments, return values, common patterns.

assistant: # Metadata

[image reference removed]

Metadata panel.

The *Metadata* panel includes options for writing metadata into render output.

Metadata Input
:   Where to grab metadata from.

    Scene:
    :   Use metadata from the current scene.

    Sequencer Strips:
    :   Use metadata from the strips in the Sequencer.

Include
:   Date
    :   Includes the current date and time.

    Time
    :   Includes the current scene time and render frame at `HH:MM:SS.FF`.

    Render Time
    :   Includes the render time.

    Frame
    :   Includes the frame number.

    Frame Range
    :   Includes the start and end frame numbers.

    Memory
    :   Includes the peak memory usage.

    Hostname
    :   Includes the rendering machine’s [hostname](https://en.wikipedia.org/wiki/Hostname).

    Camera
    :   Includes the name of the active camera.

    Lens
    :   Includes the name of the active camera’s lens value.

    Scene
    :   Includes the name of the active scene.

    Marker
    :   Includes the name of the last marker.

    Filename
    :   Includes the filename of the blend-file.

    Strip Name
    :   Includes the name of the foreground sequence strip.
user: Describe Relocate Library from the Blender manual or Python API, including usage steps and snippets.

assistant: When the Outliner is in the *Blender File* [Display Mode](../../editors/outliner/interface.xhtml#bpy-types-spaceoutliner-display-mode),
a right-click on a library (a linked blend-file) will show the *Relocate* option.
It allows to replace it by a different file.
This can be used to either fix a broken linked library (e.g. because the file was moved
or renamed), or to switch to a variation of the same data in a different file.

### Broken Libraries

If Blender cannot find a library while loading a blend-file,
it will create placeholder data-blocks to replace missing linked ones.
That way, references to the missing data are not lost, and by relocating the missing library,
the lost data can be automatically restored.
user: Provide the full official documentation entry for Snap, preserving all code examples.

assistant: The toggle button enables/disables automatic keyframe snapping.
The dropdown button shows a popover with the following options:

Snap To
:   Type of element to snap to.

    Frame:
    :   Snap to full frames.

    Second:
    :   Snap to seconds.

    Nearest Marker:
    :   Snap to the nearest [Marker](../../animation/markers.html).

Absolute Time Snap
:   When disabled, keyframes will move in increments of *Snap To*.
    For example, if you selected *Second* and have a keyframe that’s currently on
    0:06+5, dragging it to the right will snap it to 0:07+5. Its time
    increases by a second, and its subsecond offset of 5 frames remains the same.

    When enabled, keyframes will snap to multiples of *Snap To*.
    Taking the above example, the keyframe would snap to 0:07+0,
    removing the subsecond offset.
user: Describe Split from the Blender manual or Python API, including usage steps and snippets.

assistant: The *Split* operator separates the selected portion of a curve from the rest,
creating a new, independent curve segment.
This curve can then be moved or altered without affecting the other curve.

- If a segment of the curve is selected, it will be split off
  as a new curve that can be moved or edited independently.
- If only a single control point is selected, it will be duplicated as a loose control point,
  while the original remains attached to the rest of the curve.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Data Type
:   The [data type](../../attributes_reference.xhtml#attribute-data-types) used for the retrieved data.
    [Attribute Search](../../inspection.xhtml#geometry-nodes-attribute-search) can be used to give a basic list of possible
    attribute names and data types. When a value is chosen from the search menu, the data
    type is set to automatically choose the data type from the geometry nodes result.
user: Give a detailed overview of MovieTrackingPlaneMarkers(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # MovieTrackingPlaneMarkers(bpy_struct)

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

*class* bpy.types.MovieTrackingPlaneMarkers(*bpy_struct*)
:   Collection of markers for movie tracking plane track

    find_frame(*frame*, *\**, *exact=True*)
    :   Get plane marker for specified frame

        Parameters:
        :   - **frame** (*int in* *[**0**,* *1048574**]*) – Frame, Frame number to find marker for
            - **exact** (*boolean**,* *(**optional**)*) – Exact, Get plane marker at exact frame number rather than get estimated marker

        Returns:
        :   Plane marker for specified frame

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

    insert_frame(*frame*)
    :   Insert a new plane marker at the specified frame

        Parameters:
        :   **frame** (*int in* *[**0**,* *1048574**]*) – Frame, Frame number to insert marker to

        Returns:
        :   Newly created plane marker

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

    delete_frame(*frame*)
    :   Delete plane marker at specified frame

        Parameters:
        :   **frame** (*int in* *[**0**,* *1048574**]*) – Frame, Frame number to delete plane marker from

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

assistant: This API gives access the Blender’s internal mesh editing API, featuring geometry connectivity data and
access to editing operations such as split, separate, collapse and dissolve.
The features exposed closely follow the C API,
giving Python access to the functions used by Blender’s own mesh editing tools.

For an overview of BMesh data types and how they reference each other see:
[BMesh Design Document](https://developer.blender.org/docs/features/objects/mesh/bmesh/).
user: What is Quick Start and how is it used in Blender Python scripting?

assistant: Artists can add Grease Pencil to any existing Blender scene, or start with a 2D Animation template.
The template offers some pre-configured options that are helpful for animation and storyboarding.

### Create and Use Grease Pencil

1. From [Object Mode](../scene_layout/object/introduction.html), Add ‣ Grease Pencil ‣ Blank.
2. Create a new keyframe or turn on Auto Key. (See [Keyframe Editing](../animation/keyframes/editing.html))
3. Switch to [Draw Mode](modes/draw/introduction.html).
4. Click and drag across the viewport to add strokes to the Grease Pencil object.

### 2D Animation Template

To create a new Blender file using the “2D Animation”
project template use: File ‣ New ‣ 2D Animation.

Note the following pre-configured setup for the 2D Animation template:

- 2D Animation is the default active workspace.
- World Properties ‣ Surface (Background) ‣ Color is set to white.
- Color management [Views](../render/color_management/displays_views.html#bpy-types-colormanagedviewsettings-view-transform) is set to *Standard*.
- The [drawing plane](modes/draw/drawing_planes.html) is set to Front (X-Z).
- Line and Fill layers, along with some stroke materials, are configured for Grease Pencil.
- The animation timeline will automatically create a new keyframe when Grease Pencil is used on empty frames.
user: Describe Example from the Blender manual or Python API, including usage steps and snippets.

assistant: This example shows the usage of distance from a target object to dynamically control
a [Wave](../deform/wave.xhtml) modifier with a modified vertex group:

[The blend-file](https://archive.blender.org/wiki/2015/index.php/File:ManModifiersWeightVGroupEx.blend),
TEST_1 scene.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`RenderEngine.render`](bpy.types.RenderEngine.html#bpy.types.RenderEngine.render "bpy.types.RenderEngine.render") | - [`Scene.render`](bpy.types.Scene.html#bpy.types.Scene.render "bpy.types.Scene.render") |
user: What is NodeTreeInterfaceSocketVector(NodeTreeInterfaceSocket) and how is it used in Blender Python scripting?

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

    default_value
    :   Input value used for unconnected socket

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

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: These strips control when a [Speaker Objects](../../render/output/audio/speaker.xhtml) starts to playback the audio.
Playback continues the length of audio file and does not take into account the length of the sound strip.
user: Explain Rotation to Quaternion Node in complete detail according to the official Blender documentation.

assistant: # Rotation to Quaternion Node

[image reference removed]

The *Rotation to Quaternion* node converts a standard rotation value to a
[quaternion rotation](../../../../advanced/appendices/rotations.html#quaternion-mode).
user: Explain Spot Light in complete detail according to the official Blender documentation.

assistant: A spot light emits a cone-shaped beam of light from the tip of the cone,
in a given direction.

Power
:   Power of the light. Higher values increase the intensity of the light.
    Negative values can be set, but should be avoided for predictable and physically based result.

Radius
:   When larger than zero, light will be emitted from a spherical surfaces with the specified radius.
    Lights with larger size have softer shadows and specular highlights.

Soft Falloff
:   Apply falloff to avoid sharp edges when the light geometry intersects with other objects.

### Beam Shape

[image reference removed]

Changing the spot options also changes the appearance of the spotlight as displayed in the 3D Viewport.

Angle
:   The size of the outer cone of a spot light, which determines how wide the light spreads.
    A smaller angle produces a narrow, focused beam, while a larger angle results in a wider,
    softer illumination area.

    This value represents the angle at the top of the light cone in degrees,
    and can range from **1.0°** (narrow beam) to **180.0°** (very wide beam).

    Changing the spot *Angle* option

    |  |  |
    | --- | --- |
    | ../../_images/render_lights_light-object_size45.png   Angle: 45° | ../../_images/render_lights_light-object_size60.png   Angle: 60° |

Blend
:   The *Blend* slider controls the inner cone of the spot.
    The *Blend* value can be between (0.0 to 1.0).
    The value is proportional and represents that amount of space that the inner cone should
    occupy inside the outer cone *Size*.

    The inner cone boundary line indicates the point at which light from the spot will start to blur/soften;
    before this point its light will mostly be full strength.
    The larger the value of *Blend* the more blurred/soft the edges of the spotlight will be,
    and the smaller the inner cone’s circular area will be (as it starts to blur/soften earlier).

    To make the spot have a sharper falloff rate and therefore less blurred/soft edges,
    decrease the value of *Blend*.
    Setting *Blend* to 0.0 results in very sharp spotlight edges, without any transition between light and shadow.

    The falloff rate of the spot light is a ratio between the *Blend* and *Size* values;
    the larger the circular gap between the two, the more gradual the light fades between *Blend* and *Size*.

    *Blend* and *Size* only control the spot light cone’s aperture and softness (“radial” falloff);
    they do not control the shadow’s softness as shown below.

    [image reference removed]

    Render showing the soft edge spotlighted area and the sharp/hard object shadow.

    Notice in the picture above that the object’s shadow is sharp as a result of the ray tracing,
    whereas the spotlight edges are soft.
    If you want other items to cast soft shadows within the spot area, you will need to alter other shadow settings.

Show Cone
:   Displays a transparent cone in 3D Viewport to visualize which objects are contained in it.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

The Texture Node Editor allows creating custom textures by combining colors,
procedural patterns, and images in various ways. This is a step up from the
[built-in textures](../../render/materials/legacy_textures/introduction.xhtml),
where you can select a type from a list and not much more.

[image reference removed]

Combined textures based on nodes.
user: Give a detailed overview of Volume Displace Modifier: syntax, arguments, return values, common patterns.

assistant: # Volume Displace Modifier

The *Volume Displace* modifier displaces existing volume grids based on a 3D texture.
It uses the RGB color channels of the texture to displace the volume into the X, Y and Z direction.
user: Describe Select Grouped from the Blender manual or Python API, including usage steps and snippets.

assistant: Select all tracks from specified group.

Action
:   The group of tracks to select.

    Keyframed Tracks:
    :   Select all keyframed tracks.

    Estimated Tracks:
    :   Select all estimated tracks.

    Tracked Tracks:
    :   Select all tracked tracks.

    Locked Tracks:
    :   Select all locked tracks.

    Disabled Tracks:
    :   Select all disabled tracks.

    Track with Same Color:
    :   Select all tracks with same color as active track.

    Failed Tracks:
    :   Select all tracks which failed to be reconstructed.
user: What is Loose Geometry and how is it used in Blender Python scripting?

assistant: Depending on the [selection mode](introduction.xhtml#bpy-types-toolsettings-mesh-select-mode),
this operator selects vertices that are not part of any edge, edges that are not
part of any face, or faces that do not share an edge with any other face.
user: Show practical ways to work with NodeMenuSwitchItems(bpy_struct) in a Blender add-on or script – include code.

assistant: # NodeMenuSwitchItems(bpy_struct)

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

*class* bpy.types.NodeMenuSwitchItems(*bpy_struct*)
:   Collection of items that make up an enum

    new(*name*)
    :   Add an a new enum item

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

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

        Parameters:
        :   **item** ([`NodeEnumItem`](bpy.types.NodeEnumItem.html#bpy.types.NodeEnumItem "bpy.types.NodeEnumItem"), (never None)) – Item, The item to remove

    clear()
    :   Remove all items

    move(*from_index*, *to_index*)
    :   Move an item to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the item to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the item

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

assistant: This add-on is enabled by default, in case it is not:

1. Open Blender and go to [Add-ons](../../editors/preferences/addons.html) section of the [Preferences](../../editors/preferences/index.html).
2. Search “Scalable Vector Graphics (SVG)” and check the *Enable Add-on* checkbox.
user: Give a detailed overview of GPENCIL_UL_annotation_layer(UIList): syntax, arguments, return values, common patterns.

assistant: # GPENCIL_UL_annotation_layer(UIList)

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

*class* bpy.types.GPENCIL_UL_annotation_layer(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *_icon*, *_active_data*, *_active_propname*, *_index*)

    *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 Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

Screw panel (in Edit Mode).

Steps
:   The number of extrusions to be done for each 360° turn.

Turns
:   The number of turns to create.

Center X, Y, Z
:   The world space coordinates of the centerpoint around which to spin the geometry.
    Initially this is the location of the 3D Cursor.

Axis X, Y, Z
:   The direction vector around which to spin the geometry.
    Initially this is the screen-space vertical axis (so the global Z axis when in a
    side view or the global Y axis when in top view). By inverting the *Axis*,
    you can flip between going clockwise and counterclockwise.

Notice that the *Axis* only determines how the geometry spins “horizontally” around
the centerpoint. It doesn’t determine how the geometry moves “vertically.”
Instead, the geometry always moves by a distance and direction given by the endpoints
of the open profile, and goes downward in the object’s local space.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Copy Location constraint.

[Target](../interface/common.html#rigging-constraints-interface-common-target)
:   The object or bone whose location to copy.

Axis
:   The axes for which to copy location coordinates.

Invert
:   The axes for which invert the sign (so a coordinate of 10 becomes -10 and vice versa).

Offset
:   When enabled, the target’s current position (from all its constraints) is not copied over,
    but added to the owner’s original position (from its preceding constraints).

[Target/Owner](../interface/common.html#rigging-constraints-interface-common-space)
:   The spaces for retrieving the coordinates from the target and for applying them to the owner.

[Influence](../interface/common.html#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Geometry
:   Standard geometry input.

Selection
:   Boolean field for specifying which elements should be selected in the output geometry.
    Elements for which this field evaluates to false are implicitly de-selected.
user: Provide the full official documentation entry for Operating System Settings, preserving all code examples.

assistant: Make this installation your default Blender (MS-Windows & Linux only).

On Linux, if Blender is installed from a package manager such as Snap,
file association is handled by the package manager.

Register
:   Make the currently in use Blender installation the default
    for generating thumbnails and the default for opening blend-files.

Unregister
:   Remove file association & thumbnailer.

For All Users
:   Register Blender for all users, requires escalated privileges.
user: Describe Palette Operators from the Blender manual or Python API, including usage steps and snippets.

assistant: # Palette Operators

bpy.ops.palette.color_add()
:   Add new color to active palette

bpy.ops.palette.color_delete()
:   Remove active color from palette

bpy.ops.palette.color_move(*\**, *type='UP'*)
:   Move the active Color up/down in the list

    Parameters:
    :   **type** (enum in [`'UP'`, `'DOWN'`], (optional)) – Type

bpy.ops.palette.extract_from_image(*\**, *threshold=1*)
:   Extract all colors used in Image and create a Palette

    Parameters:
    :   **threshold** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Threshold

bpy.ops.palette.join(*\**, *palette=''*)
:   Join Palette Swatches

    Parameters:
    :   **palette** (*string**,* *(**optional**,* *never None**)*) – Palette, Name of the Palette

bpy.ops.palette.new()
:   Add new palette

bpy.ops.palette.sort(*\**, *type='HSV'*)
:   Sort Palette Colors

    Parameters:
    :   **type** (enum in [`'HSV'`, `'SVH'`, `'VHS'`, `'LUMINANCE'`], (optional)) – Type
user: Provide the full official documentation entry for NodeOutputs(bpy_struct), preserving all code examples.

assistant: # NodeOutputs(bpy_struct)

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

*class* bpy.types.NodeOutputs(*bpy_struct*)
:   Collection of Node Sockets

    new(*type*, *name*, *\**, *identifier=''*, *use_multi_input=False*)
    :   Add a socket to this node

        Parameters:
        :   - **type** (*string**,* *(**never None**)*) – Type, Data type
            - **name** (*string**,* *(**never None**)*) – Name
            - **identifier** (*string**,* *(**optional**,* *never None**)*) – Identifier, Unique socket identifier
            - **use_multi_input** (*boolean**,* *(**optional**)*) – Make the socket multi-input (valid for inputs only)

        Returns:
        :   New socket

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

    remove(*socket*)
    :   Remove a socket from this node

        Parameters:
        :   **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket")) – The socket to remove

    clear()
    :   Remove all sockets from this node

    move(*from_index*, *to_index*)
    :   Move a socket to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the socket to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the 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: What is License and how is it used in Blender Python scripting?

assistant: # License

Blender itself is released under the [GNU General Public License](https://www.gnu.org/licenses/gpl-3.0.html).
More info can be found at: [blender.org/about/license](https://www.blender.org/about/license/).

Except where otherwise noted, the content of the Blender Manual is available under a [Creative Commons
Attribution-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-sa/4.0/) or any later
version. Excluded from the CC-BY-SA license are any logos, trademarks, icons, source code and Python scripts used
in this manual.

For any references to material from this manual, please attribute the “Blender Documentation Team” and include a
hyperlink (online) or URL (in print) to the manual. For example:

```
The Blender 5.0 Manual
by the Blender Documentation Team
is licensed under a CC-BY-SA v4.0.
```

See [Best practices for attribution](https://wiki.creativecommons.org/wiki/Marking/Users) for further explanation.

It means that when contributing to the manual, you do not hold exclusive copyright to, or ownership of, your text. You
are, of course, acknowledged and appreciated for your contribution. However, others can change and improve your text
in order to keep the manual consistent and up to date.

Previous versions of the Blender Manual are made available under an [Open Content License](https://web.archive.org/web/19981206111937/http://www.opencontent.org/opl.shtml) v2.26 – v2.77.
user: How do I use Distance from Camera in Blender? Include parameters, examples, warnings and best practices.

assistant: # Distance from Camera

The *Distance from Camera* modifier alters the base property with a new one
from a given range using the distance to the active *camera*.

Range Min, Max
:   The limits of the mapping from “distance to camera” to “property in mapping”.
    If the current point of the stroke is at *Range Min* or less from the active camera or the object,
    it will take the start value. And conversely,
    if it is at *Range Max* or more from the camera/object, it will take the end value.
    These values are in the current scene’s units, not in pixels!

Fill Range by Selection
:   Set the min/max range values from the distances between the current selected mesh vertices and
    the camera or the target.
user: Provide the full official documentation entry for Resource Information, preserving all code examples.

assistant: The right side of the Status Bar displays information about the Blender instance.
Which information is shown can be chosen by `RMB` on the Status Bar
or in the [Preferences](../../editors/preferences/interface.xhtml#prefs-interface-status-bar).

[image reference removed]

Scene Statistics
:   Shows information about the data in the active scene.

    - **Collection**: The name of the active [Collection](../../scene_layout/collections/index.xhtml).
    - **Active Object**: The name of the active selected object.
    - **Geometry**: Information about the current scene depending on the mode and object type.
      This can be the number of vertices, faces, triangles, or bones.
    - **Objects**: The number of selected objects and the total count of objects.

Scene Duration
:   Shows the total amount of time of the playback along with the current frame number and total frame count.
    The format of the duration text is determined by the
    [Timecode Style](../../editors/preferences/animation.xhtml#bpy-types-preferencesview-timecode-style).

System Memory
:   Shows an estimate of Blender’s RAM consumption. On a single-instance single-machine scenario,
    this estimate provides a measurement against the hardware limit of the machine.

Extensions Updates
:   Shows the number of [extensions](../../advanced/extensions/index.xhtml) with available updates.

Blender Version
:   Shows the version number of Blender that is currently running.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

A strip is a container which carries frames provided by one or more sources (input).
It is defined by a *Start Frame* and a *Length*, and is displayed as a colored horizontal rectangle.

[image reference removed]

Strip schematic.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Grid
:   The resulting SDF grid after the boolean operation is applied.
    The output maintains valid signed distance values and can be converted
    to a mesh using the [Grid to Mesh](grid_to_mesh.html)
    node or used in further volumetric operations.
user: How do I use NodeSocketFloatDistance(NodeSocketStandard) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeSocketFloatDistance(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.NodeSocketFloatDistance(*NodeSocketStandard*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float in [-inf, inf], default 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: What is Objects and how is it used in Blender Python scripting?

assistant: ### New Objects

Link Materials To
:   To understand this option properly, you need to understand how Blender works with Objects.
    Almost everything in Blender is organized in a hierarchy of data-blocks.
    A data-block can be thought of as containers for certain pieces of information. For example,
    the Object data-block contains information about the Object’s location, rotation, and scale
    while the associated linked Object Data’s data-block contains information about the mesh.

    [image reference removed]

    Example for a mesh.

    A material may be linked in two different ways:

    Object Data:
    :   Any created material will be created as part of the Object Data’s data-block.

    Object:
    :   Any created material will be created as part of the Object’s data-block.

    [image reference removed]

    A material linked to Object Data (left) and Object (right).

Align to
:   World:
    :   New objects align with world coordinates.

    View:
    :   New object align with view coordinates.

    3D Cursor:
    :   New objects align to the 3D cursor’s orientation.

Enter Edit Mode
:   If selected, Edit Mode is automatically activated when you create a new object.

Instance Empty Size
:   The display size for empties when
    a new [collection instance](../../scene_layout/object/properties/instancing/collection.xhtml) is created.

### Copy on Duplicate

The checkboxes define what data is copied with a duplicated object and
what data remains linked. Any boxes that are checked will have their data copied along with
the duplication of the object. Any boxes that are not checked will instead have their data linked
from the source object that was duplicated.

For example, if you have *Mesh* checked,
then a full copy of the mesh data is created with the new object,
and each mesh will behave independently of the duplicate.
If you leave the mesh box unchecked then when you change the mesh of one object,
the change will be mirrored in the duplicate object.

The same rules apply to each of the checkboxes in the data-block list.
user: Describe Bpy.Types.Particlesettings from the Blender manual or Python API, including usage steps and snippets.

assistant: adaptive_subframes ParticleSettings.use_advanced_hair ParticleSettings.use_close_tip ParticleSettings.use_clump_curve ParticleSettings.use_clump_noise ParticleSettings.use_collection_count ParticleSettings.use_collection_pick_random ParticleSettings.use_dead ParticleSettings.use_die_on_collision ParticleSettings.use_dynamic_rotation ParticleSettings.use_emit_random ParticleSettings.use_even_distribution ParticleSettings.use_global_instance ParticleSettings.use_hair_bspline ParticleSettings.use_modifier_stack ParticleSettings.use_multiply_size_mass ParticleSettings.use_parent_particles ParticleSettings.use_react_multiple ParticleSettings.use_react_start_end ParticleSettings.use_regrow_hair ParticleSettings.use_render_adaptive ParticleSettings.use_rotation_instance ParticleSettings.use_rotations ParticleSettings.use_roughness_curve ParticleSettings.use_scale_instance ParticleSettings.use_self_effect ParticleSettings.use_size_deflect ParticleSettings.use_strand_primitive ParticleSettings.use_twist_curve ParticleSettings.use_velocity_length ParticleSettings.use_whole_collection ParticleSettings.userjit ParticleSettings.virtual_parents ParticleSettings.bl_rna_get_subclass() ParticleSettings.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Explain Bone(bpy_struct) in complete detail according to the official Blender documentation.

assistant: r child in pbone.children:
                    rec(child, matrix)

            # Scan all bone trees from their roots.
            for pbone in obj.pose.bones:
                if not pbone.parent:
                    rec(pbone, None)
        ```

    *classmethod* MatrixFromAxisRoll(*axis*, *roll*)
    :   Convert the axis + roll representation to a matrix

        Parameters:
        :   - **axis** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], (never None)) – The main axis of the bone (tail - head)
            - **roll** (*float in* *[**-inf**,* *inf**]*) – The roll of the bone

        Returns:
        :   The resulting orientation matrix

        Return type:
        :   [`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix") of 3 \* 3 items in [-inf, inf]

    *classmethod* AxisRollFromMatrix(*matrix*, *\**, *axis=(0.0, 0.0, 0.0)*)
    :   Convert a rotational matrix to the axis + roll representation. Note that the resulting value of the roll may not be as expected if the matrix has shear or negative determinant.

        Parameters:
        :   - **matrix** ([`mathutils.Matrix`](mathutils.html#mathutils.Matrix "mathutils.Matrix") of 3 \* 3 items in [-inf, inf], (never None)) – The orientation matrix of the bone
            - **axis** (*float array* *of* *3 items in* *[**-inf**,* *inf**]**,* *(**optional**)*) – The optional override for the axis (finds closest approximation for the matrix)

        Returns:
        :   `result_axis`, The main axis of the bone, [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf]

            `result_roll`, The roll of the bone, float in [-inf, inf]

        Return type:
        :   ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], float in [-inf, inf])

    parent_index(*parent_test*)
    :   The same as ‘bone in other_bone.parent_recursive’
        but saved generating a list.

    translate(*vec*)
    :   Utility function to add *vec* to the head and tail of this bone.

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

assistant: - The pull request text should be usable as the git commit message (see the [guidelines](../../guides/commit_guide.html#contribute-commit-good-message) for details).
- Be explicit when some changes are to be addressed before committing, without the need for a review iteration.
- If the pull request is not approved the author is expected to make another iteration.
- If the change needs agreement on the design task first, put the pull request on hold by adding a `WIP:` prefix in
  the title, indicating the author considers the pull request not ready to be merged. No review is expected unless the
  author specifically asks for it.
- Writers are expected to reply to pull requests in 3 working days.
- Add relevant modules/projects to the labels.
- Encourage new writes to do review, it’s a good way to learn and important to grow the project.
user: How do I use GeometryNodeInputRadius(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeInputRadius(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.GeometryNodeInputRadius(*GeometryNode*)
:   Retrieve the radius at each point on curve or point cloud geometry

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

assistant: Projects the selected faces onto a virtual cylinder, then unrolls that cylinder.
The cylinder is centered on the [Transform Pivot Point](../../../editors/3dview/controls/pivot_point/index.html),
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.html).

### Options

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

Direction, Align
:   The direction of the cylinder’s central 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 cylinder will be rotated by 90° around its 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 cylinder will be rotated by 90° around its axis and the
        UV map will be shifted horizontally by a quarter.

Pole
:   How to handle vertices that lie on the cylinder’s central axis.

    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.

|  |  |  |
| --- | --- | --- |
| ../../../_images/modeling_meshes_editing_uv_unwrap-pole.png   Unwrapping the top of a dome. | ../../../_images/modeling_meshes_editing_uv_unwrap-pinch.png   Pole set to Pinch. | ../../../_images/modeling_meshes_editing_uv_unwrap-fan.png   Pole set to Fan. |

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

Radius
:   Half the height of the cylinder (i.e. *not* its radius; we’re only using the cylinder
    for projection, so its radius doesn’t matter).

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.html), and this node must be selected in the
    [Shader Editor](../../../editors/shader_editor.html).

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: Show practical ways to work with Transform Pivot Point in a Blender add-on or script – include code.

assistant: # Transform Pivot Point

The *Pivot Point* determines the location of the
[Object Gizmo](../../display/gizmo.html).
Changing this location can make it easier to perform
transformations around the point you want.

[image reference removed]

With the default “Median Point” pivot point (left) it’s tricky to
bring the second wheel spoke into place, but with “3D Cursor” (right)
it’s easy.

The Pivot Point can be changed using a selector in the 3D Viewport’s header:

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

assistant: # Sculpting Tools

Brush
:   Tool to use for any of the sculpting [brushes](brushes.xhtml).

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

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

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

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