PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Memory Management from the Blender manual or Python API, including usage steps and snippets.

assistant: In EEVEE, GPU
Memory management is done by the GPU driver.
In theory, only the needed textures and meshes (now referred as “the resources”) for a single draw call
(i.e. one object) needs to fit into the GPU memory.

So if the scene is really heavy,
the driver will swap things in and out to make sure all objects are rendered correctly.

In practice, using too much GPU memory can make the GPU driver crash, freeze, or kill the application.
So be careful of what you ask.

There is no standard way of estimating if the resources will fit into the GPU memory and/or
if the GPU will render them successfully.
user: Show practical ways to work with Force Fields Settings in a Blender add-on or script – include code.

assistant: The Force Field Settings panel allows you to make each individual act as a force field,
allowing them to affect other dynamic systems, or even, each other.

Self Effect
:   Causes the particle force fields to have an effect on other particles within the same system.

Effector Amount
:   Set how many of the particles act as force fields. 0 means all of them are effectors.

You can give particle systems up to two force fields. By default they do not have any.
Choose an effector type from the selector to enable them.
Settings are described in the [Common Settings section](../../forces/force_fields/introduction.html#force-field-common-settings).
user: Describe UI_UL_list(UIList) from the Blender manual or Python API, including usage steps and snippets.

assistant: # UI_UL_list(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.UI_UL_list(*UIList*)
:   *static* filter_items_by_name(*pattern*, *bitflag*, *items*, *propname='name'*, *flags=None*, *reverse=False*)
    :   Set FILTER_ITEM for items which name matches filter_name one (case-insensitive).
        pattern is the filtering pattern.
        propname is the name of the string property to use for filtering.
        flags must be a list of integers the same length as items, or None!
        return a list of flags (based on given flags if not None),
        or an empty list if no flags were given and no filtering has been done.

    *classmethod* sort_items_by_name(*items*, *propname='name'*)
    :   Re-order items using their names (case-insensitive).
        propname is the name of the string property to use for sorting.
        return a list mapping org_idx -> new_idx,
        or an empty list if no sorting has been done.

    *static* sort_items_helper(*sort_data*, *key*, *reverse=False*)
    :   Common sorting utility. Returns a neworder list mapping org_idx -> new_idx.
        sort_data must be an (unordered) list of tuples [(org_idx, …), (org_idx, …), …].
        key must be the same kind of callable you would use for sorted() builtin function.
        reverse will reverse the sorting!

    *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 NodeTreeInterfaceSocketVectorVelocity2D(NodeTreeInterfaceSocket) in a Blender add-on or script – include code.

assistant: # NodeTreeInterfaceSocketVectorVelocity2D(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.NodeTreeInterfaceSocketVectorVelocity2D(*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: Describe Smooth from the Blender manual or Python API, including usage steps and snippets.

assistant: For Bézier curves, this smoothing operation reduces the distance between
the selected control point(s) and their neighbors,
while keeping the neighbors anchored. Does not effect control point tangents.

[image reference removed]

Original, unsmoothed Curve.

[image reference removed]

Entire curve smoothed over 20 times by holding `Shift`-`R` to repeat last step.

[image reference removed]

Only three control points in the center smoothed over 20 times.
user: How do I use Info Operators in Blender? Include parameters, examples, warnings and best practices.

assistant: # Info Operators

bpy.ops.info.report_copy()
:   Copy selected reports to clipboard

bpy.ops.info.report_delete()
:   Delete selected reports

bpy.ops.info.report_replay()
:   Replay selected reports

bpy.ops.info.reports_display_update()
:   Update the display of reports in Blender UI (internal use)

bpy.ops.info.select_all(*\**, *action='SELECT'*)
:   Change selection of all visible reports

    Parameters:
    :   **action** (enum in [`'TOGGLE'`, `'SELECT'`, `'DESELECT'`, `'INVERT'`], (optional)) –

        Action, Selection action to execute

        - `TOGGLE`
          Toggle – Toggle selection for all elements.
        - `SELECT`
          Select – Select all elements.
        - `DESELECT`
          Deselect – Deselect all elements.
        - `INVERT`
          Invert – Invert selection of all elements.

bpy.ops.info.select_box(*\**, *xmin=0*, *xmax=0*, *ymin=0*, *ymax=0*, *wait_for_input=True*, *mode='SET'*)
:   Toggle box selection

    Parameters:
    :   - **xmin** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – X Min
        - **xmax** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – X Max
        - **ymin** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Y Min
        - **ymax** (*int in* *[**-inf**,* *inf**]**,* *(**optional**)*) – Y Max
        - **wait_for_input** (*boolean**,* *(**optional**)*) – Wait for Input
        - **mode** (enum in [`'SET'`, `'ADD'`, `'SUB'`], (optional)) –

          Mode

          - `SET`
            Set – Set a new selection.
          - `ADD`
            Extend – Extend existing selection.
          - `SUB`
            Subtract – Subtract existing selection.

bpy.ops.info.select_pick(*\**, *report_index=0*, *extend=False*)
:   Select reports by index

    Parameters:
    :   - **report_index** (*int in* *[**0**,* *inf**]**,* *(**optional**)*) – Report, Index of the report
        - **extend** (*boolean**,* *(**optional**)*) – Extend, Extend report selection
user: What is 3D Viewport and how is it used in Blender Python scripting?

assistant: ### Rotate UVs

The orientation of the UV texture is defined by each face.
If the image is, for example, upside down or laying on its side,
use the Face ‣ Rotate UVs (in the 3D Viewport in Face Select mode)
menu to rotate the UVs per face in 90-degree turns.

### Reverse UVs

The Face ‣ Reverse UVs tool mirrors the UVs per face,
which flips the image over, showing you the image reversed.
user: Show practical ways to work with ShaderFxPixel(ShaderFx) in a Blender add-on or script – include code.

assistant: # ShaderFxPixel(ShaderFx)

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

*class* bpy.types.ShaderFxPixel(*ShaderFx*)
:   Pixelate effect

    size
    :   Pixel size

        Type:
        :   int array of 2 items in [1, 32767], default (0, 0)

    use_antialiasing
    :   Antialias pixels

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Mode
:   Determines how to choose which layers are merged.

    By Name:
    :   Combine all layers which have the same name.

    By Group ID:
    :   Provide a custom group ID for each layer and all layers with the same ID will be merged into one.
user: Give a detailed overview of Output Nodes: syntax, arguments, return values, common patterns.

assistant: # Output Nodes

Output nodes are the final node in every node tree.
Although you can add more than one, only one will be used (indicated by a colored or darkened header).
Output nodes are always preceded by [Shaders](../shader/index.xhtml)
except in the case of the [Displacement](../../materials/components/displacement.xhtml) of a Material Output.
user: Describe Inflate from the Blender manual or Python API, including usage steps and snippets.

assistant: # Inflate

Similar to [Draw](clay.xhtml),
except that vertices are moved in the direction of their own normals.
Especially useful when sculpting meshes with a lot of curvature.

Also available as a [Mesh Filter](../tools/mesh_filter.xhtml)
to inflate all unmasked areas at once.
user: Give a detailed overview of NodeSocketIntPercentage(NodeSocketStandard): syntax, arguments, return values, common patterns.

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

    default_value
    :   Input value used for unconnected socket

        Type:
        :   int in [0, inf], default 100

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

assistant: Undo Steps
:   Number of Undo steps available.

Undo Memory Limit
:   Maximum memory usage in Mb (0 is unlimited).

Global Undo
:   This enables Blender to save actions done when you are **not** in *Edit Mode*.
    For example, duplicating objects, changing panel settings or switching between modes.

Console Scroll-back Lines
:   The number of lines, buffered in memory of the console window.
    Useful for debugging purposes and command-line rendering.

Texture Time Out
:   Time since last access of a GL texture in seconds, after which it is freed.
    Set this to 0 to keep textures allocated.

    Garbage Collection Rate
    :   Number of seconds between each run of the GL texture garbage collector.

VBO Time Out
:   Time since last access of a GL vertex buffer object (VBO) in seconds after which it is freed
    (set to 0 to keep VBO allocated).

    Garbage Collection Rate
    :   Number of seconds between each run of the GL vertex buffer object garbage collector.

Shader Compilation Method
:   Defines the method used for compiling GPU shaders in parallel.

    - This option is not available on macOS and requires using OpenGL backend.
    - Changing this setting requires restarting Blender to take effect.

    Thread:
    :   Uses multiple threads within a single process to compile shaders concurrently.
        This method is more memory-efficient but may be slower on some systems.

    Subprocess:
    :   Uses multiple separate subprocesses to compile shaders in parallel.
        This can be faster, especially on systems with high core counts, but consumes significantly more RAM.

Threads / Subprocesses
:   The number of shader compilation threads or subprocesses to use.
    The maximum value is limited by the number of logical CPU cores on the system.

    Increasing the number can reduce shader compilation time at the cost of higher memory usage.
    A value of 0 lets Blender automatically choose a suitable number based on the system configuration.

    - This option is not available on macOS and requires using OpenGL backend.
    - Changing this setting requires restarting Blender to take effect.
user: Describe ViewerNodeViewerPathElem(ViewerPathElem) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ViewerNodeViewerPathElem(ViewerPathElem)

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

*class* bpy.types.ViewerNodeViewerPathElem(*ViewerPathElem*)
:   node_id
    :   Type:
        :   int in [-inf, inf], default 0

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

assistant: ### Invalid Selection

There are times when selection fails under some configurations. Often, this is noticeable in mesh *Edit Mode*,
selecting vertices/edges/faces where random elements are selected.

Internally Blender uses [OpenGL](../glossary/index.xhtml#term-OpenGL) for selection, so the graphics card driver requires Blender to give it correct
results in the format it expects.

Possible Solutions:

Disable [Multisampling](../glossary/index.xhtml#term-Multisampling)
:   This is by far the most common cause of selection issues.

    There are known problems with some graphics cards when using multisampling.

    You can disable this option by turning multisampling off in your graphics card driver options.

Change Anti-Aliasing Sample Settings
:   Depending on your OpenGL configuration, some specific sample settings may work while others fail.

    Unfortunately finding a working configuration involves trial & error testing.

Upgrade Graphics Driver
:   As with any OpenGL-related issues, using recent drivers can resolve problems.

    However, it should be noted that this is a fairly common problem and remains unresolved with many drivers.
user: Show practical ways to work with Sidebar in a Blender add-on or script – include code.

assistant: The Sidebar region contains properties for
the currently selected node as well as node editor-specific settings.

### Node

[image reference removed]

Node tab with a compositing Render Layers node selected.

#### Node

Name
:   A unique node identifier inside this node tree.

Label
:   Nodes can be given a title by modifying the text field.

Warning Propagation
:   Controls which warnings in this node will be propagated to the parent node group or modifier.
    This only exists for Geometry Nodes.

##### Color

By default, the node’s background color is defined by the user theme.
This color can be overridden by selecting a custom color in this panel.
Custom node colors can be used to provide a visual cue to help distinguish some nodes from others.
The button to the right of the checkbox lets you save colors as presets
for reusing later on (much like a palette).

Color
:   Color of the node background.

    Node Color Specials
    :   This menu contains [Operators](../../operators.xhtml) for working with nodes with custom colors.

        Copy Color
        :   Copies the color of the [Active](../../../glossary/index.xhtml#term-Active) node and applies it to all selected nodes.

#### Properties

The properties that are shown depend on the type of node selected,
e.g. a Mix node has different properties than a Mask node.

#### Custom Properties

Create and manage your own properties to store data in the active node.
See the [Custom Properties](../../../files/custom_properties.xhtml#files-data-blocks-custom-properties) page for more information.

### Tool

#### Active Tool

The info in this panel changes with the selected tool.

### View

#### Annotations

You can select the Annotate tool in the Toolbar to make annotations in the node editor.
See [Annotate Tool](../../annotate_tool.xhtml) for more info.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Transform Space
:   The transformation of the vector and geometry outputs.

    Original:
    :   Output the geometry relative to the input object transform, and the location,
        rotation and scale relative to the world origin.

    Relative:
    :   Bring the input object geometry, location, rotation and scale into the modified object,
        maintaining the relative position between the two objects in the scene.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

Opacity Modifier.

Mode
:   The color transformation will be applied to the stroke/fill color or stroke Hardness.
    When Hardness is selected the opacity affects the stroke’s transparency (alpha) from the center to the border.

    Stroke & Fill, Stroke, Fill, or Hardness

Uniform Opacity
:   When enabled, makes the opacity equal for the entire strokes.

    Strength
    :   Absolute opacity for the stroke points.

Opacity Factor
:   Controls the opacity value of the stroke points.
    A value of 1.0 respect the original alpha value of the points,
    a shift less than 1.0 make the points more transparent than originally,
    and a shift greater than 1.0 make the points more opaque than originally.

    Sets value to 2.0 makes the points alpha fully opaque.

### Influence

See [Influence Filters](../introduction.html#grease-pencil-modifier-influence-filters).
user: Describe Python in Blender from the Blender manual or Python API, including usage steps and snippets.

assistant: Blender has an embedded Python interpreter which is loaded when Blender is started
and stays active while Blender is running. This interpreter runs scripts to draw the user interface
and is used for some of Blender’s internal tools as well.

Blender’s embedded interpreter provides a typical Python environment, so code from tutorials
on how to write Python scripts can also be run with Blender’s interpreter. Blender provides its
Python modules, such as `bpy` and [`mathutils`](mathutils.html#module-mathutils "mathutils"), to the embedded interpreter so they can
be imported into a script and give access to Blender’s data, classes, and functions.
Scripts that deal with Blender data will need to import the modules to work.

Here is a simple example which moves a vertex attached to an object named “Cube”:

```
import bpy
bpy.data.objects["Cube"].data.vertices[0].co.x += 1.0
```

This modifies Blender’s internal data directly.
When you run this in the interactive console you will see the 3D Viewport update.
user: Provide the full official documentation entry for Set Spline Resolution Node, preserving all code examples.

assistant: # Set Spline Resolution Node

[image reference removed]

The *Set Spline Resolution* node sets the value for how many evaluated points should be generated on the curve for
every control point. It only has an effect on [NURBS](../../../../glossary/index.html#term-NURBS), [Bézier](../../../../glossary/index.html#term-Bezier), and Catmull Rom splines. In case of
Bézier splines, the resolution does not have an effect on segments between vector handles.

The evaluated points are displayed in the viewport, used in the
[Curve to Mesh Node](../operations/curve_to_mesh.html) node,
and optionally used in the [Resample Curve Node](../operations/resample_curve.html).

The input node for this data is the [Spline Resolution Node](../read/spline_resolution.html).
user: Explain bpy_extras submodule (bpy_extras.keyconfig_utils) in complete detail according to the official Blender documentation.

assistant: # bpy_extras submodule (bpy_extras.keyconfig_utils)

bpy_extras.keyconfig_utils.addon_keymap_register(*keymap_data*)
:   Register a set of keymaps for addons using a list of keymaps.

    See ‘blender_defaults.py’ for examples of the format this takes.

bpy_extras.keyconfig_utils.addon_keymap_unregister(*keymap_data*)
:   Unregister a set of keymaps for addons.

bpy_extras.keyconfig_utils.keyconfig_test(*kc*)
user: Show practical ways to work with Points to Curves Node in a Blender add-on or script – include code.

assistant: # Points to Curves Node

[[image reference removed]](../../../_images/node-types_GeometryNodePointsToCurves.webp)

The *Points to Curves* node generates a [Curves](../../curves/introduction.html) geometry by taking all
points and inserting them to new curves. All [Attributes](../attributes_reference.html)
from points are propagated to [Curve Points](../attributes_reference.html#attribute-domains).
[Built-in](../attributes_reference.html#geometry-nodes-builtin-attributes) curves attributes stored in points will be ignored.
user: How do I use Global Transform in Blender? Include parameters, examples, warnings and best practices.

assistant: # Global Transform

Copy and paste object and bone transforms with ease.

When copying, the global ([World Space](../../../glossary/index.xhtml#term-World-Space)) transform is placed on the clipboard.
This can then be pasted onto any object or bone, at the current frame or at another one.

[image reference removed]

The figure on the right shows the main functionality of the Copy Global
Transform panel. The collapsed panels are described each in their own section
below.

Copy
:   Inspects the active Object (in Object mode) or Bone (in Pose mode) and places
    its current global transform onto the clipboard as a matrix.

Paste
:   Takes the copied global transform and applies it to the active Object or Bone.
    This is done by **adjusting its location, rotation, and scale properties**.

Mirrored
:   Same as ‘Paste’ above, but then mirrored relative to some other object or
    bone. This can be useful, for example, to copy the foot position of one foot
    to the other. See [Mirror](#copy-global-transform-mirror-options) below.

Paste to Selected Keys
:   Paste as described above and additionally use auto-keying to update one or
    more frames. The key selection is used to tell Blender *which frames* this
    should happen on; it does not influence which parts of the transform are
    keyed. *What* is keyed is determined by the active keying set.

Paste and Bake
:   Almost the same as *Paste to Selected Keys*. Instead of only pasting on the
    selected keys, *Paste and Bake* will paste & auto-key on every frame between
    the first and last selected keys.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Vector
:   Vector specifying the displacement along three axes.
    This is where a texture node can be connected.

    Typically a baked vector displacement image texture is used.
    For Object Space, RGB colors in the image are interpreted as an XYZ offset in object space.
    For Tangent Space, R is an offset along the tangent, G along the normal and B along the bitangent.

Midlevel
:   Neutral displacement value that causes no displacement.
    With the default 0.0, any lower values will cause the surfaces to be pushed inwards,
    and any higher values will push them outwards.

Scale
:   Increase or decrease the amount of displacement.
user: Explain ShaderFxSwirl(ShaderFx) in complete detail according to the official Blender documentation.

assistant: # ShaderFxSwirl(ShaderFx)

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

*class* bpy.types.ShaderFxSwirl(*ShaderFx*)
:   Swirl effect

    angle
    :   Angle of rotation

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

    object
    :   Object to determine center location

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

    radius
    :   Radius to apply

        Type:
        :   int in [0, 32767], default 0

    use_transparent
    :   Make image transparent outside of radius

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Combine Spherical Node

[image reference removed]

The *Combine Spherical* node converts spherical coordinates (R, Φ, Θ)
into a Cartesian vector (X, Y, Z). It is the inverse of the
[Separate Spherical](separate_spherical.html) node.

Spherical coordinates represent a point in 3D space by its distance from the origin,
horizontal rotation, and vertical inclination, which can be useful for constructing
radial or rotational patterns and generating coordinates on a sphere.
user: Provide the full official documentation entry for Selecting Bone Joints, preserving all code examples.

assistant: To select bones’ joints you have the [standard selection](../../../scene_layout/object/selecting.xhtml) methods.

### Inverse Selection

As stated above, you have to remember that these selection tools are for bones’ joints only,
not the bones’ bodies.

For example, the *Inverse* selection option `Ctrl`-`I`
inverts the selection of bones’ joints, not of bones (see *Inverse selection*).

Remember that a bone is selected only if both its joints are selected. So,
when the selection status of bones’ joints is inverted, a new set of bones is selected.

Inverse selection.

|  |  |
| --- | --- |
| ../../../_images/animation_armatures_bones_selecting_two-bones.png   Two bones selected. | ../../../_images/animation_armatures_bones_selecting_three-ends.png   The result of the inverse selection `Ctrl`-`I`: The bones joints selection has been inverted, and not the bones selection. |

### Selecting Connected Bone Joints

Another example is: when you select the root of a bone connected to its parent,
you also implicitly select the tip of its parent (and vice versa).
user: Show practical ways to work with Fingers Bones in a Blender add-on or script – include code.

assistant: Start by placing, finger by finger, all the knuckles in place.

[image reference removed]

Knuckles Edge Loops and Cursor Snapping.

Finalize the positioning by taking care of bone rolls (the X axis is set as bend axis).

[image reference removed]

Fingers Bend Axis.

When the fingers are in place proceed placing the palm bones.

[image reference removed]

Palm Alignment.
user: How do I use GREASE_PENCIL_UL_masks(UIList) in Blender? Include parameters, examples, warnings and best practices.

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

assistant: # Scene Strip

Scene strips are a way to insert the render output of another scene into your sequence.
Instead of rendering out a video, then inserting the video file, you can insert the scene directly.

The strip length will be determined based on the animation settings in that scene.
user: What is Read View Layers and how is it used in Blender Python scripting?

assistant: Reads all the current scene’s render layers from cache, as needed.
This can be used to save RAM while rendering because the render layers do not have to be saved in RAM.
And also for recovering some information from a failed render.
For this to work, [Cache Result](../../../render/output/properties/output.html#bpy-types-rendersettings-use-render-cache) must be enabled.
user: Give a detailed overview of ID Node: syntax, arguments, return values, common patterns.

assistant: # ID Node

[image reference removed]

The *ID* node gives an integer value indicating the stable random identifier of each element on the point domain,
which is stored in the `id` attribute.

The node to set this data is the [Set ID Node](../write/set_id.xhtml) node.
user: Show practical ways to work with Brush Settings in a Blender add-on or script – include code.

assistant: Mode
:   Defines how Color Attributes affect to the strokes.

    Stroke and Fill:
    :   Color Attributes affects both the Stroke and Fill materials.

    Stroke:
    :   Color Attributes affects the Stroke material only.

    Fill:
    :   Color Attributes affects the Fill material only.
user: Give a detailed overview of Example: syntax, arguments, return values, common patterns.

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

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

assistant: # Boolean Modifier

The *Boolean* modifier combines multiple meshes using a Boolean operation.

[image reference removed]

Applying the modifier to a sphere and creating the Intersection, Union, and Difference
with a cube. The cube is hidden for a better view.
user: Show practical ways to work with ThemeRegionsAssetShelf(bpy_struct) in a Blender add-on or script – include code.

assistant: # ThemeRegionsAssetShelf(bpy_struct)

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

*class* bpy.types.ThemeRegionsAssetShelf(*bpy_struct*)
:   Theme settings for asset shelves

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

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

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

assistant: # GeometryNodeSampleCurve(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.GeometryNodeSampleCurve(*GeometryNode*)
:   Retrieve data from a point on a curve at a certain distance from its start

    data_type
    :   Type:
        :   enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items), default `'FLOAT'`

    mode
    :   Method for sampling input

        - `FACTOR`
          Factor – Find sample positions on the curve using a factor of its total length.
        - `LENGTH`
          Length – Find sample positions on the curve using a distance from its beginning.

        Type:
        :   enum in [`'FACTOR'`, `'LENGTH'`], default `'FACTOR'`

    use_all_curves
    :   Sample lengths based on the total length of all curves, rather than using a length inside each selected curve

        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: Give a detailed overview of Navigation Gizmo: syntax, arguments, return values, common patterns.

assistant: The navigation gizmo can be found in the top right of the editor.

Navigation Gizmo (left) and Navigation Gizmo in camera view (right).

|  |  |
| --- | --- |
| ../../../_images/editors_3dview_navigate_introduction_gizmo.png | ../../../_images/editors_3dview_navigate_introduction_gizmo_camera_view.png |

The Orbit gizmo at the top shows the current orientation of the view.
Dragging it with `LMB` will [orbit](navigation.xhtml#bpy-ops-view3d-view-orbit) the view.
Clicking any of the axis labels will [align](viewpoint.xhtml) the view to that axis.
Clicking the same axis again switches to the opposite side of that same axis.

The four buttons below the orbit gizmo do the following:

- [Zoom the 3D Viewport](navigation.xhtml#bpy-ops-view3d-zoom)
- [Pan the 3D Viewport](navigation.xhtml#bpy-ops-view3d-view-pan)
- [Toggle the Camera View](camera_view.xhtml)
- [Toggle the Projection](projections.xhtml) /
  [Toggle Lock Camera to View](../sidebar.xhtml#bpy-types-spaceview3d-lock-camera) (in camera view)
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Grid
:   The input signed distance field to offset.

Distance
:   The offset distance applied to the surface, in world units.
    Positive values expand the surface (dilation), and negative values contract it (erosion).
    The offset is applied uniformly in all directions, preserving smoothness and the signed distance property.
user: Show practical ways to work with ShaderNodeRadialTiling(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeRadialTiling(ShaderNode)

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

*class* bpy.types.ShaderNodeRadialTiling(*ShaderNode*)
:   Transform Coordinate System for Radial Tiling

    normalize
    :   Normalize the X coordinate of the Segment Coordinates output to a [0, 1] interval and offset the Y coordinate into a [0, infinity) interval. When checked, the textures are stretched to fit into each angular segment. When not checked, the parts of the textures that don’t fit into each angular segment are cropped

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

assistant: # Perspective/Orthographic

This operator changes the projection of the viewport camera.
Each 3D Viewport supports two different types of projection.
These are demonstrated in the Fig. below.

|  |  |
| --- | --- |
| ../../../_images/editors_3dview_navigate_projections_view-orthographic.png   Orthographic projection. | ../../../_images/editors_3dview_navigate_projections_view-perspective.png   Perspective projection. |

Our eyes are used to perspective viewing where distant objects appear smaller.
Orthographic projection often seems a bit odd at first,
because objects stay the same size regardless of their distance.
It is like viewing the scene from an infinitely distant point.
Nevertheless, orthographic viewing can be very useful,
because it provides a more “technical” insight into the scene,
making it easier to model and judge proportions.
user: Describe Sepia Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Sepia Node

[image reference removed]

The *Sepia* node applies a warm, brownish color tint to the image, emulating the look of
vintage photographs or old film prints.
It can be used to create nostalgic, cinematic, or stylized color grades that mimic
chemical sepia toning processes used in traditional photography.
user: Explain Action Track in complete detail according to the official Blender documentation.

assistant: The topmost track with the orange header holds the action that’s being edited. Normally this is the
object’s active action, but if you select a strip and press `Tab` to enter Tweak Mode,
you can temporarily make that one editable instead –
in the [Action Editor](../dope_sheet/modes/action.xhtml)
or the [Graph Editor](../graph_editor/introduction.xhtml), for example.

The Action Track has one of the following buttons:

Push Down Action
:   Not available in Tweak Mode. Creates a new track below the Action Track and moves the active action
    into it as a strip, leaving the Action Track empty. (If you create a keyframe after this,
    Blender will automatically create a new active action to hold it.)

    [image reference removed]

    Push Down Action button.

Pin
:   Only available in Tweak Mode. When unchecked, the action’s keyframes are shown at their original
    time points, rather than their new time points resulting from the strip being moved and scaled.

    [image reference removed]

    Strip at its original time point.

    [image reference removed]

    Strip moved. Notice that the keyframes are now shown to start at frame 20, which is also
    how the animation will behave. Within the action, however, they still start at frame 1.

    [image reference removed]

    After unchecking the Pin icon, the keyframes are shown at their original time points.
user: Give a detailed overview of Animation Editors: syntax, arguments, return values, common patterns.

assistant: # Animation Editors

Blender provides a set of editors designed for creating, editing, and refining animation.
These editors let you work with keyframes, curves, non-linear actions, drivers,
video sequencing, and motion tracking as part of the animation pipeline.

Each editor serves a different purpose:

- The [Dope Sheet](../editors/dope_sheet/introduction.xhtml) organizes and manipulates keyframes
  across multiple objects and data-blocks.
- The [Graph Editor](../editors/graph_editor/introduction.xhtml) provides fine control over F-Curves
  to refine motion and interpolation.
- The [Nonlinear Animation (NLA) Editor](../editors/nla/introduction.xhtml) arranges and layers animation
  actions for complex sequencing.
- The [Drivers Editor](../editors/drivers_editor.xhtml) links properties with expressions
  for procedural animation.
- The [Movie Clip Editor](../editors/clip/introduction.xhtml) supports motion tracking, mask editing,
  and stabilization, which can be integrated into animation and compositing workflows.
- The [Video Sequence Editor](../editors/video_sequencer/introduction.xhtml) (VSE) combines
  rendered animations, image sequences, audio, and effects into a final movie edit.

Together, these editors form the backbone of Blender’s animation system –
from quick keyframe adjustments to advanced rigging, motion editing, visual effects integration,
and final shot assembly.

This page describes features that are shared across the different animation focused editors.
user: Describe Time Offset Modifier from the Blender manual or Python API, including usage steps and snippets.

assistant: # Time Offset Modifier

The *Time Offset* Modifier applies a temporal offset to Grease Pencil keyframes on your timeline.
If you have duplicated a Grease Pencil object you can use the Time Offset Modifier on the copies to
desynchronize their animation. This can give more natural looking results.

Using the Time Offset Modifier it’s possible to have Grease Pencil frame ranges play back as repeating loops.
Traditionally, 2D animation that uses looped drawings includes characters walking, rising smoke, and falling
rain.
In Fixed Frame mode the Time Offset Modifier can display drawings on your timeline entirely independently of
the playhead position.

This can be handy for displaying drawings that will appear often in your animation. Think of switching between
predefined mouth shapes for instance.