PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for NodeTreeInterfaceSocketVectorAcceleration2D(NodeTreeInterfaceSocket), preserving all code examples.

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

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 2 items in [-inf, inf], default (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: Provide the full official documentation entry for Separate Bundle Node, preserving all code examples.

assistant: # Separate Bundle Node

[image reference removed]

The *Separate Bundle* node extracts individual values from a
[Bundle](../../../../interface/controls/nodes/types/utilities/bundles/index.xhtml).
Each output corresponds to an element in the bundle, identified by its socket name.

This node is the counterpart of the
[Combine Bundle](../../../../interface/controls/nodes/types/utilities/bundles/combine_bundle.xhtml)
node and is typically used to retrieve structured data that was previously grouped together.
user: Describe Interface from the Blender manual or Python API, including usage steps and snippets.

assistant: Color Picker
:   The large color field lets you pick two color components at once, depending on the selected picker type.
    The third component (such as value or saturation) is controlled with a slider next to the color field.

    The picker’s appearance and behavior depend on the type chosen in the Preferences; see [Types](#types) below.

Value/Lightness
:   The vertical slider with a gradient background defines the brightness or lightness of the selected color.
    You can scroll the `Wheel` for fine adjustments or click and drag the handle.

Below the color picking widget are a few options, the first affects how the color component’s values are computed.

Linear:
:   Displays color component values in the scene’s [linear working](../../../render/color_management/color_spaces.html#bpy-types-blendfilecolorspace-working-space)
    color space used internally for rendering and compositing.

Perceptual:
:   Displays color component values in the color picking space (*sRGB* by default),
    which matches the visual appearance of the color widgets and is more intuitive for user selection.

The next set of options change the [Color Model](../../../glossary/index.html#term-Color-Model) that is used.
The available options depend on the [Color Picker Type](../../../editors/preferences/interface.html#bpy-types-preferencesview-color-picker-type).

RGB:
:   Defines a color by directly mixing *Red*, *Green*, and *Blue* components.

HSV/HSL:
:   Defines a color by adjusting *Hue*, *Saturation*, and *Value* (or Lightness).
    Useful for adjusting color tone and intensity independently.

Component Values
:   The numeric fields below the picker show the component values (RGB or HSV/HSL).
    Blender expresses these in the range **0.0 to 1.0**.
    For color inputs that include an [Alpha Channel](../../../glossary/index.html#term-Alpha-Channel), an additional slider and field are shown.

Hex
:   Displays or accepts the color’s hexadecimal (hex) representation.
    Hex shorthand notation can be used (for example, `FC0` for `FFCC00`).

Eyedropper
:   Samples a color from anywhere inside the Blender window using the [Eyedropper](../buttons/eyedropper.html#ui-eyedropper).

    The sampled colors are read in **linear color space**, so they do not account for display transformations
    such as view or exposure adjustments.
    Sampling colors from overlays, reference images, or video preview regions may be inaccurate
    since those may be drawn after color management transforms.
user: Provide the full official documentation entry for NodeTreeInterfaceSocketFloatColorTemperature(NodeTreeInterfaceSocket), preserving all code examples.

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

    default_value
    :   Input value used for unconnected socket

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

assistant: If you unwrap an entire mesh in one go, the resulting UV map may look rather messy.
In the example below, the ear and facial features are squashed and the neck is stretched
out way too far:

[image reference removed]

Bad unwrap, note ear and neck.

While you could of course start fixing this UV map by hand, it’s probably a better
idea to drop it and unwrap the mesh differently. We’ll divide it into pieces,
unwrapping each one separately with the most suitable projection.

We start by selecting just the head – excluding the eyes, ears, and neck –
and unwrapping it using [Sphere Projection](../../editing/uv.html#bpy-ops-uv-sphere-project):

[image reference removed]

Unwrapping just the head.

Next, select the ear, align the 3D Viewport view to look straight at it,
and unwrap it using [Project from View](../../editing/uv.html#bpy-ops-uv-project-from-view).

[image reference removed]

Unwrapping the ear.

The UV Editor only shows the ear at this point, but don’t worry: the UV coordinates
for the head are still there, just hidden. To make them visible again, either
select the head in the 3D Viewport again or enable
[Sync Selection](../../../../editors/uv/selecting.html#bpy-types-toolsettings-use-uv-select-sync) in the UV Editor.

Next, you can unwrap the neck using [Cylinder Projection](../../editing/uv.html#bpy-ops-uv-cylinder-project).

Once everything is unwrapped, you can select the whole mesh in the 3D Viewport to
see to the full UV map. Most likely, the different UV parts or “islands” will be
overlapping; you can fix this in the following ways:

- For each island, select a vertex and press `Ctrl`-`L` to select all the vertices
  it’s connected (Linked) to. You can also hover over the vertex and press `L`,
  or simply set the [Selection Mode](../../../../editors/uv/selecting.html#bpy-ops-uv-select-mode) to *Island*.
  Once the island is selected, scale it down and move it to a place where it no
  longer overlaps the others.
- Alternatively, you can simply click [Pack Islands](../editing.html#bpy-ops-uv-pack-islands) in the menu
  to have Blender lay out the islands automatically.

[image reference removed]

UV maps arranged together and stitched.

As a final step, you can align the islands to each other by moving and scaling,
then connect them using [Merge](../editing.html#bpy-ops-uv-weld) – or better yet, [Stitch](../editing.html#bpy-ops-uv-stitch).
user: Give a detailed overview of Handles & Interpolation Mode Display: syntax, arguments, return values, common patterns.

assistant: Dope Sheet can display the Bézier handle type associated with the keyframe,
and mark segments with non-Bézier interpolation.
This facilitates basic editing of interpolation without the use of the Graph Editor.

The icon shape represents the type of the [Bézier Handles](../../editors/graph_editor/fcurves/properties.xhtml#editors-graph-fcurves-settings-handles)
belonging to the keyframe.

[image reference removed]

From top: summary, Bézier, linear.

|  |  |
| --- | --- |
| Circle | Auto Clamped (default) |
| Circle With Dot | Automatic |
| Square | Vector |
| Clipped Diamond | Aligned |
| Diamond | Free |

If the handles of a keyframe have different types,
or in case of summary rows representing multiple curves,
out of the available choices the icon that is furthest down the list is used.
This means that if a grouped row uses a circle icon,
it is guaranteed that none of the grouped channels have a non-auto key.

Horizontal green lines mark the use of
non-Bézier [Interpolation](../../editors/graph_editor/fcurves/properties.xhtml#editors-graph-fcurves-settings-interpolation).
The line is dimmed in summary rows if not all grouped channels have the same interpolation.

Display of this information can be disabled via the *Show Handles and Interpolation*
option of the Dope Sheet’s [View Menu](../../editors/dope_sheet/navigating.xhtml#dope-sheet-view-menu).
user: Show practical ways to work with UDIMs in a Blender add-on or script – include code.

assistant: # UDIMs

Using UV maps can have one disadvantage, they consist of one texture for the entire mesh.
Most of the time this is sufficient but the disadvantage is that the texture is one resolution for the entire mesh.
This causes issues if you have a very large mesh with geometry of different importance.
When using a singular texture, the resolution might be too low to cover larger UV islands
while being inefficient for smaller, less important islands.

UDIM offers a solution to this by being able to spread UV islands across several different textures.
UDIM which stands for U DIMension is based on a tile system
where each tile is a different texture in the overall UDIM texture array.
Basically each tile consists of its own UV space (0-1, 1-2, 2-3) and have its own image assigned to that tile.
Tiles are managed in the [UDIM Tiles](#udim-tiles) panel where they can have a generated image assigned to them.
Generally, you create several textures of different resolutions;
for example, you may have a 4k resolution texture for the major details,
and 2k and/or 1k textures for less important details.

The UDIM array consists of one main tile, this tile is given the index number of `1001`.
The next tile that gets added will be `1002` and will be placed to the right of the main tile.
The overall UDIM array is ten tiles wide, so tiles `1001` through `1010` are created on the first row.
After ten tiles a new row of tiles is started above the main tile; so `1011` will be place directly above `1001`.
user: Explain NodeTreeInterfaceSocketRotation(NodeTreeInterfaceSocket) in complete detail according to the official Blender documentation.

assistant: # NodeTreeInterfaceSocketRotation(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.NodeTreeInterfaceSocketRotation(*NodeTreeInterfaceSocket*)
:   Rotation value socket of a node

    default_value
    :   Input value used for unconnected socket

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

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

assistant: |  |  |
| --- | --- |
| - [`GizmoGroup.setup_keymap`](bpy.types.GizmoGroup.html#bpy.types.GizmoGroup.setup_keymap "bpy.types.GizmoGroup.setup_keymap") - [`KeyConfig.keymaps`](bpy.types.KeyConfig.html#bpy.types.KeyConfig.keymaps "bpy.types.KeyConfig.keymaps") - [`KeyConfigurations.find_item_from_operator`](bpy.types.KeyConfigurations.html#bpy.types.KeyConfigurations.find_item_from_operator "bpy.types.KeyConfigurations.find_item_from_operator") - [`KeyMap.active`](#bpy.types.KeyMap.active "bpy.types.KeyMap.active") - [`KeyMapItems.find_match`](bpy.types.KeyMapItems.html#bpy.types.KeyMapItems.find_match "bpy.types.KeyMapItems.find_match") - [`KeyMaps.find`](bpy.types.KeyMaps.html#bpy.types.KeyMaps.find "bpy.types.KeyMaps.find") | - [`KeyMaps.find_match`](bpy.types.KeyMaps.html#bpy.types.KeyMaps.find_match "bpy.types.KeyMaps.find_match") - [`KeyMaps.find_match`](bpy.types.KeyMaps.html#bpy.types.KeyMaps.find_match "bpy.types.KeyMaps.find_match") - [`KeyMaps.find_modal`](bpy.types.KeyMaps.html#bpy.types.KeyMaps.find_modal "bpy.types.KeyMaps.find_modal") - [`KeyMaps.new`](bpy.types.KeyMaps.html#bpy.types.KeyMaps.new "bpy.types.KeyMaps.new") - [`KeyMaps.remove`](bpy.types.KeyMaps.html#bpy.types.KeyMaps.remove "bpy.types.KeyMaps.remove") - [`WindowManager.popover_end__internal`](bpy.types.WindowManager.html#bpy.types.WindowManager.popover_end__internal "bpy.types.WindowManager.popover_end__internal") |
user: What is Alpha Over and how is it used in Blender Python scripting?

assistant: With *Alpha Over*, the strips are layered up in the order selected; the first strip selected is the background,
and the second one goes *over* the first one selected.
The *Opacity* controls the transparency of the *foreground*, i.e. *Opacity* of 0.0;
will only show the background, and an *Opacity* of 1.0 will completely override the background with the foreground
(except in the transparent areas of this one, of course!)

[image reference removed]

Alpha Over Effect.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Locked Track constraint.

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

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

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

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

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Show practical ways to work with Enable Output Node in a Blender add-on or script – include code.

assistant: # Enable Output Node

[image reference removed]

The *Enable Output* node toggles the visibility and value
of a socket for a [Node Group](../../../interface/controls/nodes/groups.xhtml) outputs.
It can be used to conditionally show or hide outputs from a node group depending on an input value or condition.
user: What is Copy As New Driver and how is it used in Blender Python scripting?

assistant: A driver that sets the property value to the value of a different property can be
quickly created by using the *Copy As New Driver* context menu option of the input
property, and then pasting the result onto the output property via *Paste Driver*.

It is also possible to add the new driver variable to an existing driver using
the [Paste Driver Variables](drivers_panel.xhtml#drivers-variables) button in the editor panel.
user: Explain Other Considerations in complete detail according to the official Blender documentation.

assistant: In axis-angle and quaternion modes we can lock rotations in interactive modes in a per component basis,
instead of doing it by axis. To do so we can activate this locking ability using the lock buttons next to
the corresponding *Rotation* transform buttons.

Regarding rotation animations, all keyframes must be defined in the same rotation mode,
which must be the selected rotation mode for the object throughout the entire animation.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Mesh
:   Standard geometry input.

Level
:   The number of subdivisions to apply to the input geometry.

Edge Crease
:   Controls how smooth edges should be with [Weighted Edge Creases](../../../modifiers/generate/subdivision_surface.html#modifiers-generate-subsurf-creases).

Vertex Crease
:   Controls how much the subdivision surface should be pulled towards the vertex.
    Similar to edge creases, but allows individual vertices to be creased.

Limit Surface
:   Places vertices at the surface that would be produced with infinite
    levels of subdivision (smoothest possible shape).

UV Smooth
:   Controls how subdivision smoothing is applied to UVs.

    None:
    :   UVs remain unchanged.

    Keep Corners:
    :   UV islands are smoothed, but their boundary remain unchanged.

    Keep Corners, Junctions:
    :   UVs are smoothed, corners on discontinuous boundary and junctions of three or more regions are kept sharp.

    Keep Corners, Junctions, Concave:
    :   UVs are smoothed, corners on discontinuous boundary,
        junctions of three or more regions and darts and concave corners are kept sharp.

    Keep Boundaries:
    :   UVs are smoothed, boundaries are kept sharp.

    All:
    :   UVs and their boundaries are smoothed.

Boundary Smooth
:   Controls how open boundaries (and corners) are smoothed.

    All:
    :   Smooth boundaries, including corners.

    Keep Corners:
    :   Smooth boundaries, but corners are kept sharp.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`ParticleSystem.active_particle_target`](bpy.types.ParticleSystem.html#bpy.types.ParticleSystem.active_particle_target "bpy.types.ParticleSystem.active_particle_target") | - [`ParticleSystem.targets`](bpy.types.ParticleSystem.html#bpy.types.ParticleSystem.targets "bpy.types.ParticleSystem.targets") |
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Distribution
:   Microfacet distribution to use.

    GGX:
    :   GGX microfacet distribution.

    Multiscatter GGX:
    :   Takes multiple scattering events between microfacets into account.
        This gives more energy conserving results, which would otherwise be visible as excessive darkening.

    Beckmann:
    :   Cycles Only
        Beckmann microfacet distribution.
user: What is Curve of Point Node and how is it used in Blender Python scripting?

assistant: # Curve of Point Node

[image reference removed]

The *Curve of Point* node retrieves the index of the curve a control point is part of.
This node is conceptually similar to the [Face of Corner Node](../../mesh/topology/face_of_corner.xhtml).
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Properties are available in the *Node* tab of the Sidebar.

Sync Sockets
:   Updates the current node to match the socket signature of the connected nodes.
    Use this after renaming, adding, or removing sockets.

Define Signature
:   Locks the current item list and types to stabilize interfaces when publishing node groups.
    When enabled, adding/removing items is disabled until the option is turned off.

### Bundle Items

List of bundle items
:   Displays one entry per element in the bundle.
    Double-click to rename.

    Add Item
    :   Add a new socket to the bundle.

    Remove Item
    :   Delete the selected socket.

Type
:   The data type for the selected item (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value control is shown and used when the socket is unlinked.
user: Describe BMesh Geometry Utilities (bmesh.geometry) from the Blender manual or Python API, including usage steps and snippets.

assistant: # BMesh Geometry Utilities (bmesh.geometry)

This module provides access to bmesh geometry evaluation functions.

bmesh.geometry.intersect_face_point(*face*, *point*)
:   Tests if the projection of a point is inside a face (using the face’s normal).

    Parameters:
    :   - **face** (`bmesh.types.BMFace`) – The face to test.
        - **point** (*float triplet*) – The point to test.

    Returns:
    :   True when the projection of the point is in the face.

    Return type:
    :   bool
user: What is Bone Roll and how is it used in Blender Python scripting?

assistant: # Bone Roll

The bone roll is a part of a bone’s [rest pose](../../../../glossary/index.xhtml#term-Rest-Pose) defining its default rotation around the bone’s length.
You can control the bone roll in *Edit Mode*.
user: What is Output and how is it used in Blender Python scripting?

assistant: There are two ways to render out your audio.
You can either have it encoded with a video file or in its own audio file.
Read more on how to select a proper [audio format](../../../../render/output/properties/output.xhtml#render-output-video-encoding-audio)
and how to start [rendering](../../../../render/output/index.xhtml).
user: Give a detailed overview of Selection History: syntax, arguments, return values, common patterns.

assistant: *class* bmesh.types.BMEditSelSeq
:   add(*element*)
    :   Add an element to the selection history (no action taken if its already added).

    clear()
    :   Empties the selection history.

    discard(*element*)
    :   Discard an element from the selection history.

        Like remove but doesn’t raise an error when the elements not in the selection list.

    remove(*element*)
    :   Remove an element from the selection history.

    validate()
    :   Ensures all elements in the selection history are selected.

    active
    :   The last selected element or None (read-only).

        Type:
        :   [`bmesh.types.BMVert`](#bmesh.types.bmesh.types.BMVert "bmesh.types.bmesh.types.BMVert"), [`bmesh.types.BMEdge`](#bmesh.types.bmesh.types.BMEdge "bmesh.types.bmesh.types.BMEdge") or [`bmesh.types.BMFace`](#bmesh.types.bmesh.types.BMFace "bmesh.types.bmesh.types.BMFace")

*class* bmesh.types.BMEditSelIter
user: How do I use Advanced in Blender? Include parameters, examples, warnings and best practices.

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

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

    Brushes and Brush Types of each mode:

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

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

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

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

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

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

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

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

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

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

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

    Plane
    :   When locked keep using the plane origin of surface where stroke was initiated,
        instead of the surface plane currently under the cursor.
user: How do I use Sequencer Preview Overlays in Blender? Include parameters, examples, warnings and best practices.

assistant: # Sequencer Preview Overlays

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

Image Outline
:   Shows an outline around the selected images.

2D Cursor
:   Shows the [2D Cursor](../sidebar.xhtml#editors-sequencer-preview-2d-cursor).

Frame Overlay
:   Shows the [Frame Overlay](../sidebar.xhtml#bpy-types-sequenceeditor-show-overlay)
    for comparing the current frame to a reference frame.

Safe Areas
:   Shows guides indicating the video area where content can be seen across all screens.

Metadata
:   Shows [file metadata](../sidebar.xhtml#editors-vse-preview-sidebar-metadata).

Annotations
:   Shows [Annotations](../../../../interface/annotate_tool.xhtml).
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

Grease Pencil is a Blender object. It accepts the drawing information
from a mouse or pressure-sensitive stylus and places it in 3D space
as a collection of points, which are defined as a stroke.

The Grease Pencil object can be used to make traditional 2D animation, cut-out animation,
motion graphics, or used it as storyboard tool, among other things.

[image reference removed]

An illustration in 3D space using the Grease Pencil object.

Strokes are created in [Draw Mode](modes/draw/introduction.html),
which requires a new [keyframe](../animation/keyframes/editing.html)
in the animation timeline for the Grease Pencil object.
Existing strokes can then be adjusted in [Edit Mode](modes/edit/introduction.html)
and [Sculpt Mode](modes/sculpting/introduction.html).
Finally, artists can apply materials, modifiers, lighting, and visual effects to strokes.
user: Describe Preparations from the Blender manual or Python API, including usage steps and snippets.

assistant: If the language you want to translate has not been started by someone else already and you wish to create a set of new
files for the desired language, say ‘fr’ (French), then you must first use the environment you have created, as guided
in [Getting Started](../manual/index.xhtml#about-getting-started), in particular
[Installing Dependencies](../manual/getting_started/local_editing/install/index.xhtml) and
[Building the Manual](../manual/getting_started/local_editing/build.xhtml) sections.

This will give you a foundation environment for:

- Creating a new set of translation language from English source.
- Perform `make` command to turn translated texts in po files into html files for testing locally.
- Update changes in English texts which have been added by other contributors.

Below examples show the process to create a new set of files for French, language code `fr`, on Linux platform.
Other platforms might vary slightly but should be mainly the same.

1. [Create a Blender ID](https://id.blender.org/register/) if you have not done so already.
2. Log into [projects.blender.org](https://projects.blender.org/) and
   [Create an Issue](https://projects.blender.org/blender/documentation/issues/new)
   requesting for commit access in order to transfer changes to the central repository of the translation team.
3. Open an instance of a console application.
4. Change the current working directory to the directory of `blender-manual`, where the instance of `Makefile`
   resides.
user: Show practical ways to work with NodeSocketVectorEuler2D(NodeSocketStandard) in a Blender add-on or script – include code.

assistant: # NodeSocketVectorEuler2D(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.NodeSocketVectorEuler2D(*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: How do I use Follow Path Constraint in Blender? Include parameters, examples, warnings and best practices.

assistant: # Follow Path Constraint

The *Follow Path* constraint positions an object or bone on a [Curve](../../../modeling/curves/introduction.xhtml).
The desired position can be specified in two ways:

- Using a frame number, namely the [Evaluation Time](../../../modeling/curves/properties/path_animation.xhtml#bpy-types-curve-eval-time) of the Curve with an optional
  *Offset* in the constraint.
- Using a number between 0 and 1, namely the *Offset Factor* in the constraint.

By animating these properties, the object or bone can be made to move along the Curve.
It’s also possible to make it rotate to match the Curve’s direction.
Use cases include cameras on rails, vehicles on roads, boxes on conveyor belts, and so on.

To set up the constraint more quickly, select the object, add the Curve to the selection,
press `Ctrl`-`P`, and click *Path Constraint*.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

Python is an interpreted, interactive, object-oriented programming language.
It incorporates modules, exceptions, dynamic typing, very high-level dynamic data types, and classes.
Python combines remarkable power with very clear syntax.

Python scripts are a versatile way to extend Blender functionality.
Most areas of Blender can be scripted, including animation, rendering, import and export,
object creation and automating repetitive tasks.

To interact with Blender, scripts can make use of
the tightly integrated API.
user: Describe TextureNodeMixRGB(TextureNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # TextureNodeMixRGB(TextureNode)

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

*class* bpy.types.TextureNodeMixRGB(*TextureNode*)
:   blend_type
    :   Type:
        :   enum in [Ramp Blend Items](bpy_types_enum_items/ramp_blend_items.html#rna-enum-ramp-blend-items), default `'MIX'`

    use_alpha
    :   Include alpha of second input in this operation

        Type:
        :   boolean, default False

    use_clamp
    :   Clamp result of the node to 0.0 to 1.0 range

        Type:
        :   boolean, default False

    *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 Light Probe Plane in Blender? Include parameters, examples, warnings and best practices.

assistant: # Light Probe Plane

A light probe plane records the light incoming from a single direction for all visible points on a plane.
The specular reflection direction is the only one currently available.

This type of light probe is suited to smooth planar surfaces.

Each visible planar light probe increases the render time as the scene needs to be rendered for
each of them.

Light probe planes only work when the ray tracing method is set to `Screen-Trace`.
When enabled, they accelerate the tracing process and complete the missing data from the screen space ray tracing.
user: Show practical ways to work with ThemeTopBar(bpy_struct) in a Blender add-on or script – include code.

assistant: # ThemeTopBar(bpy_struct)

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

*class* bpy.types.ThemeTopBar(*bpy_struct*)
:   Theme settings for the Top Bar

    space
    :   Settings for space

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Sphere Projection, preserving all code examples.

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

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

[image reference removed]

Using an equirectangular image with a Sphere Projection.

### Options

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

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

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

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

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

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

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

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

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

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

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

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

Scale to Bounds
:   Stretches the resulting UV map to fill the complete texture.
user: What is Clean Up and how is it used in Blender Python scripting?

assistant: These tools help to cleanup degenerate geometry on the strokes.

### Clean Loose Points

Removes strokes with only a few points.

Limit
:   The number of points to consider a stroke as loose.

### Delete Duplicate Frames

Removes any duplicate keyframes.

### Merge by Distance

Simplifies a stroke by merging the selected points that are closer than a specified distance to each other.
Note, unless using *Unselected*, selected points must be contiguous, else they will not be merged.

Merge Distance
:   Sets the distance threshold for merging points.

Unselected
:   Allows points in selection to be merged with unselected points.
    When disabled, selected points will only be merged with other selected ones.

### Reproject Strokes

Sometimes you may have drawn strokes unintentionally in different locations in the 3D space
but they look right from a certain plane or from the camera view.
You can use Reproject to flatten all the selected strokes from a certain viewpoint.

Reprojected Type
:   Front:
    :   Reproject selected strokes onto the front plane (XZ).

    Side:
    :   Reproject selected strokes onto the side plane (YZ).

    Top:
    :   Reproject selected strokes onto the top plane (XY).

    View:
    :   Reproject selected strokes onto the current view.

    Surface:
    :   Reproject selected strokes onto the mesh surfaces.

        Surface Offset
        :   When Surface Mode is activated controls the stroke offset from the object.

    Cursor:
    :   Reproject selected strokes onto 3D cursor rotation.

Keep Original
:   Maintains the original strokes after applying the tool.

|  |  |  |  |
| --- | --- | --- | --- |
| <../../../_images/grease-pencil_modes_edit_grease-pencil-menu_reproject-strokes-1.png>   Original drawing from the front view. | <../../../_images/grease-pencil_modes_edit_grease-pencil-menu_reproject-strokes-2.png>   Original drawing in the 3D Viewport. | <../../../_images/grease-pencil_modes_edit_grease-pencil-menu_reproject-strokes-3.png>   Strokes reprojected onto the front plane to fix strokes misalignment. | <../../../_images/grease-pencil_modes_edit_grease-pencil-menu_reproject-strokes-1.png>   Drawing after reprojection operation from the front view. |