PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is GeometryNodePoints(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodePoints(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.GeometryNodePoints(*GeometryNode*)
:   Generate a point cloud with positions and radii defined by fields

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

assistant: |  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_shader_emission_example.jpg   Emission shader, with strength at 1.0. | ../../../_images/render_shader-nodes_shader_emission_example-bright.jpg   Emission shader, with strength at 3.0. |
user: Provide the full official documentation entry for Chains of Bones, preserving all code examples.

assistant: The bones inside an armature can be completely independent from each other
(i.e. the modification of one bone does not affect the others).
But this is not often a useful set up: To create a leg,
all bones “after” the thigh bone should move “with” it in a well-coordinated manner.
This is exactly what happens in armatures by parenting a bone to the next one in the limb,
you create a “chains of bones”. These chains can be ramified. For example,
five fingers attached to a single “hand” bone.

[image reference removed]

An armature with two chains of bones.

Bones are chained by linking the tip of the parent to the root of the child.
Root and tip can be *connected*, i.e. they are always exactly at the same point;
or they can be *free*, like in a standard parent-child object relationship.

A given bone can be the parent of several children,
and hence be part of several chains at the same time.

The bone at the beginning of a chain is called its *root bone*,
and the last bone of a chain is the *tip bone*
(do not confuse them with similar names of bones’ joints!).

Chains of bones are a particularly important topic in [posing](posing/index.html)
(especially with the standard *forward* kinematics versus “automatic” *inverse* kinematics posing techniques).
You create/edit them in *Edit Mode*, but except in case of connected bones,
their relationships have no effect on bone transformations in this mode
(i.e. transforming a parent bone will not affect its children).

The easiest way to manage bones relationships is to use
the [Relations panel](bones/properties/relations.html#bpy-types-editbone-parent) in the Bone tab.
user: Explain UV Tangent Node in complete detail according to the official Blender documentation.

assistant: # UV Tangent Node

[image reference removed]

The *UV Tangent* node generates tangent direction vectors based on a specified UV map.
Tangents are unit-length vectors that lie along the surface of the geometry
and point in the direction of increasing *U* coordinates in the UV space.
They are commonly used in shading and texturing workflows, for example in
normal mapping or anisotropic effects.

This node allows for either exact or approximate tangent computation, offering
a balance between precision and performance depending on the use case.
user: Describe Menu Selection Tools from the Blender manual or Python API, including usage steps and snippets.

assistant: These tools are variants of the previously described ones.
They’re available in the menu rather than the Toolbar
and work slightly differently.

### Box Select

To use this tool, you first activate the menu item or keyboard shortcut
and then drag a box as usual. Unlike *Select Box*, the default behavior
here is to add the items inside the box to the selection.
(The ones outside the box are not deselected.)

To remove the items inside the box from the selection,
hold `Shift`, or drag with `MMB` instead.

While dragging, you can additionally hold `Spacebar` to move the box around with the mouse.

### Circle Select

To use this tool, you first activate the menu item or keyboard shortcut
and then drag a circle around as usual. Unlike *Select Circle*, the default
behavior here is to add the items inside the circle to the selection.
(The ones outside the circle are not deselected.)

To remove the items inside the circle from the selection,
hold `Shift`, or drag with `MMB` instead.

You can change the radius of the circle by scrolling with the `Wheel`
or using the `NumpadPlus` and `NumpadMinus` keys.

Once activated, *Circle Select* stays active: you can release the mouse button
and start dragging somewhere else without having to press `C` again.
At the same time, however, it blocks all other parts of Blender while it’s active.
To deactivate the tool again, press `RMB`, `Return`, or `Esc`.

### Lasso Select

To use this tool, you first activate the menu item and drag a freeform shape
around the item(s) you want to select with `LMB`. The menu lets you choose
whether to set, extend or reduce the selection.

Alternatively, you can immediately start dragging with `Ctrl`-`RMB`.
Unlike *Select Lasso*, the default behavior then is to add the items inside
the lasso to the selection. (The ones outside the lasso are not deselected.)

To remove the items inside the lasso from the selection,
drag with `Shift`-`Ctrl`-`RMB` instead.

While dragging, you can additionally hold `Spacebar` to move the lasso
around with the mouse.
user: What is Overlays and how is it used in Blender Python scripting?

assistant: Overlays are information that is displayed on top of the nodes and node trees.
There is a toggle to show or hide all overlays for the node editor next to the overlay popover.

Wire Colors
:   Color node links based on their connected sockets.

Reroute Auto Labels
:   Label [Reroute Nodes](types/layout/reroute.html)
    based on the label of connected reroute nodes.

Context Path
:   Display breadcrumbs in the upper left corner indicating the hierarchy location
    of the node tree/group that’s currently being displayed.

Annotations
:   Displays [Annotations](../../annotate_tool.html) in the preview region.

Previews
:   Display each node’s [Preview](parts.html#interface-nodes-parts-preview) if the node’s preview is also toggled.

Timings
:   Display each node’s last execution time.
    This option is only available for compositing and geometry nodes.

    In the context of geometry nodes, see [Node Timings Overlay](../../../modeling/geometry_nodes/inspection.html#modeling-geometry-nodes-inspection-timings).
user: Describe Fixed Constraint from the Blender manual or Python API, including usage steps and snippets.

assistant: # Fixed Constraint

This constraint cause the two objects to move as one.
Since the physics system does have a tiny bit of slop in it,
the objects do not move as rigidly as they would if they were part of the same mesh.

[image reference removed]

*Fixed* constraint options.
user: Provide the full official documentation entry for Node Timings Overlay, preserving all code examples.

assistant: [image reference removed]

The node timings overlay.

Node timings show how long a node took to execute the last time the node group was evaluated.
They can be turned on in the overlays popover on the top right of the node editor.
When a node group is used in multiple places, the timings depend on the context of
the node editor, which is displayed in the path on the top left.

Frame nodes display the total time from all of the contained nodes
and the *Group Output* node displays the total time for the entire node group.

The displayed timings should only be considered an approximation, since they can
also take into account actions like copying or deleting a geometry input that aren’t
part of the node’s operation. Also, when a node uses multiple CPU cores, the evaluation
system might work on other nodes at the same time. It’s also important to remember
that [field nodes](fields.html#field-node-types) generally don’t do work by themselves,
so their execution time is only added to the data-flow nodes they are connected to.
user: Provide the full official documentation entry for Object, preserving all code examples.

assistant: # Object

Friction
:   The friction of the surrounding medium. Generally friction dampens a movement.
    The larger the friction, the more viscous is the medium.
    Friction always appears when a vertex moves relative to its surround medium.

Mass
:   Mass value for vertices.
    Larger mass slows down acceleration, except for gravity where the motion is constant regardless of mass.
    Larger mass means larger inertia, so also braking a soft body is more difficult.

Control Point
:   You can paint weights and use a specified vertex group for mass values.
user: Explain Local Storage in complete detail according to the official Blender documentation.

assistant: Add-ons must not assume their own directory is user writable since this may not be the case for “System” repositories.
Writing files into the add-on’s directory also has the down side that upgrading the extension will remove all files.

Add-ons which need their own user directory should use a utility function provided for this purpose:

```
extension_directory = bpy.utils.extension_path_user(__package__, path="", create=True)
```

If you wish create subdirectories, this can be done with the `path` argument.

This directory will be kept between upgrades but will be removed if the extension is uninstalled.
user: Give a detailed overview of Packed Data: syntax, arguments, return values, common patterns.

assistant: # Packed Data

Blender has the ability to encapsulate (incorporate)
various kinds of data within the blend-file that is normally saved outside of the blend-file.
For example, an image texture that is an external image file can be put “inside” the blend-file.
This allows sharing a full project as a single file,
instead of e.g. an archive containing the blend-file and all its dependencies.

You know that a data is packed when you see a little “gift box” icon displayed next to its path.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`PreferencesFilePaths.asset_libraries`](bpy.types.PreferencesFilePaths.html#bpy.types.PreferencesFilePaths.asset_libraries "bpy.types.PreferencesFilePaths.asset_libraries") |  |
user: Show practical ways to work with Toggle Local View in a Blender add-on or script – include code.

assistant: Global view shows all 3D objects in the scene. Local view isolates the selected object(s)
so that they are the only ones visible in the viewport. This is useful for working on
objects that are obscured by others, or to speed up the viewport performance in heavy scenes.
Local view is contextual, meaning that it can be set per 3D Viewport.

You can toggle between *Global* and *Local View* by selecting the option
from the View menu or using the shortcut `NumpadSlash`.

|  |  |
| --- | --- |
| ../../../_images/editors_3dview_navigate_local-view_local1.png   Global View. | ../../../_images/editors_3dview_navigate_local-view_local2.png   Local View. |

### Remove from Local View

Objects can be removed from Local View by selecting them and using the *Remove from Local View* operator.
If the last remaining object is removed, Blender will automatically return to the Global View.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Value
:   The data retrieved and interpolated from the *Mesh* geometry, mapped based on the node’s settings and inputs.

Is Valid
:   Whether the node could find a single face to sample at the UV coordinate.
user: Provide the full official documentation entry for Text & Search Fields, preserving all code examples.

assistant: [image reference removed]

A text and a search field.

Text fields show a rounded rectangular border, and optionally an icon and/or text inside the border.
Text fields store text strings, and provide the means to edit text by standard text editing shortcuts:

|  |  |
| --- | --- |
| `Home` | Go to the start of the line. |
| `End` | Go to the end of the line. |
| `Left`, `Right` | Move the cursor a single character. |
| `Ctrl`-`Left`, `Ctrl`-`Right` | Move the cursor an entire word. |
| `Backspace`, `Delete` | Delete characters. |
| `Ctrl`-`Backspace`, `Ctrl`-`Delete` | Delete words. |
| `Shift` | Select while holding the key and moving the cursor. |
| `Ctrl`-`A` | Select all text. |
| `Ctrl`-`C` | Copy the selected text. |
| `Ctrl`-`X` | Cut the selected text. |
| `Ctrl`-`V` | Paste text at the cursor position. |

For text fields with an icon and pop-ups, see [Data ID](../templates/data_block.xhtml#ui-data-id).
user: Give a detailed overview of NodeTreeInterfaceSocketVectorFactor4D(NodeTreeInterfaceSocket): syntax, arguments, return values, common patterns.

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

    default_value
    :   Input value used for unconnected socket

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

    dimensions
    :   Dimensions of the vector socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for VIEWLAYER_UL_linesets(UIList), preserving all code examples.

assistant: # VIEWLAYER_UL_linesets(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.VIEWLAYER_UL_linesets(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *icon*, *_active_data*, *_active_propname*, *index*)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: In the case of (numbered) image sequences
(e.g. `*-0001.jpg`, `*-0002.jpg`, `*-0003.jpg`, etc, of any image format), you have a choice:

Range
:   Navigate into the directory and `LMB` click and drag over a range of names to highlight multiple files.
    You can page down and continue `Shift`-`LMB` click-dragging to add more to the selection.

Batch
:   `Shift`-`LMB` click selected non-related stills for batch processing; each image will be one frame,
    in sort order, and can be a mix of file types (`jpg`, `png`, `exr`, etc.).

All
:   Press `A` to select/deselect all files in the directory.
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: ### Selecting a Brush and Material

In the Tool Settings select the brush, material and color type to use with the tool.
The Line tool uses *Draw Brush* types.
See [Brush Settings](../brushes/draw.xhtml#grease-pencil-draw-common-options) for more information.

### Creating Lines

1. Click (`LMB` or the `Pen` tip) and drag the start point.
2. Release on the desired end point.
3. After releasing you can move the start and end point by clicking and dragging on the yellow manipulators.
4. Then confirm (`Return`/`MMB`) or cancel (`Esc`/`RMB`).

While dragging you can use `Shift` to snapping the line to horizontal, vertical or 45° angle
or use `Alt` to create the line from a center point.

`NumpadPlus` and `NumpadMinus` or using the mouse `Wheel`
will increase or decrease the amount of points in the final line.

`F` will adjust the line thickness and `Shift`-`F` will adjust the opacity of the strokes.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_line_example-01.png   click and dragging the start point. | ../../../../_images/grease-pencil_modes_draw_tools_line_example-02.png   Moving start and end points with manipulators. | ../../../../_images/grease-pencil_modes_draw_tools_line_example-03.png   The line after confirming. |

### Extruding

Before confirming you can use `E` to extrude the end point of the line
to generate multiple connected lines.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_line_extrude-01.png   End point extruding. | ../../../../_images/grease-pencil_modes_draw_tools_line_extrude-02.png   Moving the end point of the last line with the manipulator. | ../../../../_images/grease-pencil_modes_draw_tools_line_extrude-03.png   The connected lines after confirming. |
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Mode
:   And:
    :   True when both inputs are true.
        ([AND](https://en.wikipedia.org/wiki/AND_gate))

    Or:
    :   True when at least one input is true.
        ([OR](https://en.wikipedia.org/wiki/OR_gate))

    Not:
    :   Opposite of the input.
        ([NOT](https://en.wikipedia.org/wiki/NOT_gate))

    Not And:
    :   (True when at least one input is false.
        [NAND](https://en.wikipedia.org/wiki/NAND_gate))

    Nor:
    :   True when both inputs are false.
        ([NOR](https://en.wikipedia.org/wiki/NOR_gate))

    Equal:
    :   True when both inputs are equal. Also known as “exclusive nor”.
        ([XNOR](https://en.wikipedia.org/wiki/XNOR_gate))

    Not Equal:
    :   ([XOR](https://en.wikipedia.org/wiki/XOR_gate))
        True when both inputs are different. Also known as “exclusive or”.

    Imply:
    :   True unless the first input is true and the second is false.
        ([IMPLY](https://en.wikipedia.org/wiki/IMPLY_gate))

    Subtract:
    :   True when the first input is true and the second is false. Also known as “”not imply”.
        ([NIMPLY](https://en.wikipedia.org/wiki/NIMPLY_gate))
user: Give a detailed overview of Closure: syntax, arguments, return values, common patterns.

assistant: # Closure

The *Closure* node defines a zone that encapsulates a reusable section of nodes behaving like a function.
It specifies inputs, outputs, and internal logic that can be executed elsewhere in the node tree using an
[Evaluate Closure](evaluate_closure.html) node.

Closures allow users to pass custom procedural logic into node groups, making tools more modular and adaptable.
Instead of duplicating or editing an existing group, a closure can expose user-defined behavior while preserving
the structure of the main system.

[image reference removed]

An empty closure zone.
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: Below are some common curves you can use to achieve desired effects.

[[image reference removed]](../../../../_images/compositing_types_color_rgb-curves_example-common-use.png)

From left to right: 1. Lighten shadows 2. Negative 3. Decrease contrast 4. Posterize.

### Color Correction using Curves

[[image reference removed]](../../../../_images/compositing_types_color_rgb-curves_example-rgb.png)

Color correction with curves.

In this example, the image has too much red in it,
so we run it through an *RGB Curves* node and reduce the Red channel.

The documentation for the [Mix Color Node](../../../../compositing/types/color/mix_color.html) has an additional
example about fixing overexposure.

### Color Correction using Black/White Levels

[[image reference removed]](../../../../_images/compositing_types_color_rgb-curves_black-white-levels.png)

Color correction with Black/White Levels.

Manually adjusting the RGB curves for color correction can be difficult.
Another option for color correction is to use the Black and White Levels instead,
which really might be their main purpose.

In this example,
the White Level is set to the color of a bright spot of the sand in the background,
and the Black Level to the color in the center of the fish’s eye.
To do this efficiently it is best to bring up the Image Editor showing the original input image.
You can then use the levels’ color picker to easily choose
the appropriate colors from the input image, zooming into pixel level if necessary.
The result can be fine-tuned with the R, G, and B curves like in the previous example.

The curve for C is used to compensate for the increased contrast that is a side effect of
setting Black and White Levels.

### Effects

[[image reference removed]](../../../../_images/compositing_types_color_rgb-curves_ex.png)

Changing colors by inverting the red channel.
user: Give a detailed overview of Mesh Volumes: syntax, arguments, return values, common patterns.

assistant: Meshes used for volume render should be closed and [Manifold](../../../glossary/index.html#term-Manifold).
That means that there should be no holes in the mesh.
Each edge must be connected to exactly two faces
such that there are no holes or T-shaped faces
where three or more faces are connected to an edge.

Normals must point outside for correct results.
The normals are used to determine if a ray enters or exits a volume,
and if they point in a wrong direction, or there is a hole in the mesh,
then the renderer is unable to decide what is the inside or outside of the volume.

These rules are the same as for rendering glass refraction correctly.
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Data Type
:   Float:
    :   The node will accumulate a *Float* field.

    Integer:
    :   The node will accumulate an *Integer* field.

    Vector:
    :   The node will accumulate a *Vector* field.

    Transform:
    :   The node will accumulate a *Matrix* field.

Domain
:   The [attribute domain](../../attributes_reference.html#attribute-domains) used for accumulation
    and for evaluation of the *Value* input.
user: Give a detailed overview of Use the Terminal: syntax, arguments, return values, common patterns.

assistant: When writing Python scripts, it’s useful to have a terminal open,
this is not the built-in Python console but a terminal application which is used to start Blender.

The three main use cases for the terminal are:

- You can see the output of `print()` as your script runs, which is useful to view debug info.
- The error traceback is printed in full to the terminal which won’t always generate an report message in
  Blender’s user interface (depending on how the script is executed).
- If the script runs for too long or you accidentally enter an infinite loop,
  `Ctrl`-`C` in the terminal (`Ctrl`-`Break` on Windows) will quit the script early.
user: How do I use Vertex Groups Panel in Blender? Include parameters, examples, warnings and best practices.

assistant: # Vertex Groups Panel

[image reference removed]

The Vertex Group panel.

Vertex groups are maintained within the *Object Data* Properties, in the *Vertex Groups* panel.

Active Vertex Group
:   A [List view](../../../../interface/controls/templates/list_view.html#ui-list-view).

    Lock
    :   Locks the group from being editable. You can only rename or delete the group.

Add Vertex Group
:   Create an empty vertex group.

Remove Vertex Group
:   Deletes the active vertex group.

Vertex Group Specials
:   Sort by Name
    :   Sorts vertex groups alphabetically.

    Sort by Bone Hierarchy

    Duplicate Vertex Group
    :   Add a copy of the active vertex group as a new group.
        The new group will be named like the original group with “_copy” appended at the end of its name.
        And it will contain associations to exactly the same vertices
        with the exact same weights as in the source vertex group.

    Copy Vertex Group to Selected
    :   Copy all vertex groups to other selected objects provided they have matching indices
        (typically this is true for copies of the mesh which are only deformed and not otherwise edited).

    Mirror Vertex Group
    :   Mirrors weights and/or flips group names.
        See [Mirror Vertex Group](../../../../sculpt_paint/weight_paint/editing.html#bpy-ops-object-vertex-group-mirror) for more information.

    Mirror Vertex Group (Topology)
    :   Performs the *Mirror Vertex Group* with [Topology Mirror](../../tools/tool_settings.html#bpy-types-mesh-use-mirror-topology) enabled.

    Remove from All Groups
    :   Unassigns the selected vertices from all (even locked) groups.
        After this operation has been performed, the vertices will no longer be contained in any vertex group.
        (Not available for locked groups.)

    Clear Active Group
    :   Remove all assigned vertices from the active group. The group is made empty.
        Note that the vertices may still be assigned to other vertex groups of the object.
        (Not available for locked groups.)

    Delete All Unlocked Groups
    :   Remove all vertex groups from the object that are *not* locked.

    Delete All Groups
    :   Remove all vertex groups from the object.

    Lock All
    :   Lock all groups.

    Unlock All
    :   Unlock all groups.

    Lock Invert All
    :   Invert group locks.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: A, B
:   Standard value inputs of the selected type.

C
:   Compared against the dot product of two input vectors in when the *Mode* property is set to *Dot Product*.

Epsilon
:   This value is used as a threshold for still considering the two inputs as equal
    for the Equal and Not Equal operations.
user: Describe Window Stereo 3D Display from the Blender manual or Python API, including usage steps and snippets.

assistant: An essential component of the Stereoscopy pipeline is the ability to display the stereo image in a proper display.
Blender supports from high-end 3D displays to simple red-cyan glasses.
On top of that, you can set a different display mode for each window.

The display mode can be changed via the Window menu
or if you create your own shortcuts for the `wm.set_stereo_3d` operator.

[image reference removed]

Window menu, stereo 3D operator.

### Display Mode

Anaglyph
:   Render two differently filtered colored images for each eye.
    Anaglyph glasses are required. We support red-cyan, green-magenta and yellow-blue glasses.

Interlace
:   Render two images for each eye into one interlaced image.
    A 3D-ready monitor is required. We support Row, Column and Checkerboard Interleaved.
    An option to Swap Left/Right helps to adjust the image for the screen. This method works better in fullscreen.

Time Sequential
:   Render alternate eyes.
    This method is also known as Page Flip.
    This requires the graphic card to support Quad Buffer and it only works in fullscreen.

Side-by-Side
:   Render images for left and right eye side-by-side.
    There is an option to support Cross-Eye glasses.
    It works only in fullscreen, and it should be used with the Full Editor operator.

Top-Bottom
:   Render images for left and right eye one above another.
    It works only in fullscreen, and it should be used with the Full Editor operator.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`CacheFile.active_index`](bpy.types.CacheFile.html#bpy.types.CacheFile.active_index "bpy.types.CacheFile.active_index") | - [`CacheFile.object_paths`](bpy.types.CacheFile.html#bpy.types.CacheFile.object_paths "bpy.types.CacheFile.object_paths") |
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Iterations
:   Number of times to execute the zone. The *Iteration* socket gives the index of
    the current iteration, starting from 0.

Geometry
:   Default geometry input. Further inputs can be added by connecting a node’s output
    to the zone’s blank input, or by using the *Repeat Items* list in the node’s
    *Properties* panel.

    The inputs can be renamed by clicking them with `Ctrl`-`LMB` in the zone
    itself or in the *Repeat Items* list. The latter also accepts double clicking.
user: What is Introduction and how is it used in Blender Python scripting?

assistant: # Introduction

[Constraints](../../../glossary/index.xhtml#term-Constraint) (also known as joints) for rigid bodies connect two rigid bodies.
The physics constraints are meant to be attached to an [Empty](../../../glossary/index.xhtml#term-Empty) object.
The constraint then has fields which can be pointed at the two physics-enabled object
which will be bound by the constraint.
The empty object provides a location and axis for the constraint distinct from the two constrained objects.
The location of the entity hosting the physics constraint marks a location and
set of axes on each of the two constrained objects.
These two anchor points are calculated at the beginning of the animation and their position and
orientation remain fixed in the *local* coordinate system of the object for the duration of the animation.
The objects can move far from the constraint object, but the constraint anchor moves with the object.
If this feature seems limiting, consider using multiple objects with a non-physics *Child of* constraint and
animate the relative location of the child.
user: How do I use Select Similar in Blender? Include parameters, examples, warnings and best practices.

assistant: Select all strokes with similar characteristics.

Mode
:   The characteristics to compare.

    Layer:
    :   Selects all the points/strokes with a similar layer index.

    Material:
    :   Selects all the points/strokes with a similar material index.

    Vertex Color:
    :   Selects all the points/strokes with a similar vertex color.

    Radius:
    :   Selects all the points/strokes with a similar stroke radius.

    Opacity:
    :   Selects all the points/strokes with a similar layer opacity

Threshold
:   How similar the selection must be.
user: Provide the full official documentation entry for Marble, preserving all code examples.

assistant: # Marble

The marble texture is used to generate marble, fire, or noise with a structure.
Bands are generated based on the sine, saw, or triangular formula and noise turbulence.

[image reference removed]

Marble Texture panels.
user: Show practical ways to work with Group in a Blender add-on or script – include code.

assistant: # Group

A [Group Node](../../interface/controls/nodes/groups.xhtml) combines a set of nodes into a single one,
and selectively exposes inputs and outputs of those nodes.

Group nodes can simplify a node tree by hiding away complexity and reusing functionality.
user: Describe Setting Up Materials from the Blender manual or Python API, including usage steps and snippets.

assistant: Grease Pencil materials can be created in the [Material properties](../../editors/properties_editor.html)
as any other materials in Blender.
See [Material assignment](../../render/materials/assignment.html) for more information.

The 3D Viewport can be set to Material Preview or Rendered shading,
to interactively preview how the material looks in the scene.

Grease Pencil materials are data-blocks that can be [assigned](../../render/materials/assignment.html)
to one or more objects, and different materials can be assigned to different strokes.

In Grease Pencil the [brush](../modes/draw/brushes/index.html)
settings together with the material used will define the look and feel of the final strokes.

[Materials slots](properties.html#gp-material-slots) also have some extra controls
that help to work with materials while drawing or editing lines.
user: Provide the full official documentation entry for ActionChannelbags(bpy_struct), preserving all code examples.

assistant: # ActionChannelbags(bpy_struct)

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

*class* bpy.types.ActionChannelbags(*bpy_struct*)
:   For each action slot, a list of animation channels that are meant for that slot

    new(*slot*)
    :   Add a new channelbag to the strip, to contain animation channels for a specific slot

        Parameters:
        :   **slot** ([`ActionSlot`](bpy.types.ActionSlot.html#bpy.types.ActionSlot "bpy.types.ActionSlot")) – Action Slot, The slot that should be animated by this channelbag

        Returns:
        :   Newly created channelbag

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

    remove(*channelbag*)
    :   Remove the channelbag from the strip

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: ### UV Overlap

In general overlapping UVs are not supported (as with texture baking).

However, this is only a problem when a single brush stroke paints onto multiple faces
that share a texture.

### Perspective View & Faces Behind the View

When painting onto a face which is partially behind the view (in perspective mode),
the face cannot be painted on.
To avoid this, zoom out or use an orthographic viewport.

### Perspective View & Low Poly

When painting onto a face in perspective mode onto a low-poly object with
normals pointing away from the view, painting may fail; to workaround disable
the [Normal Falloff](../brush/falloff.xhtml#bpy-types-imagepaint-use-normal-falloff) option in the stroke settings.

Typically this happens when painting onto the side of a cube
(see [Blender bug #34665](https://projects.blender.org/blender/blender/issues/34665)).
user: Provide the full official documentation entry for Zoom, preserving all code examples.

assistant: Zoom Method
:   Choose your preferred style of zooming in and out,
    when using interactive zoom.

    Scale:
    :   *Scale* zooming depends on where you first click in the view.
        To zoom out, move the cursor to the area center.
        To zoom in, move the cursor away from the area center.

    Continue:
    :   The *Continue* zooming option allows you to control the speed
        (and not the value) of zooming by moving away from the initial cursor position.

        Moving up from the initial click point or to the right will zoom out,
        moving down or to the left will zoom in. The further away you move,
        the faster the zoom movement will be.
        The directions can be altered by the *Vertical* and *Horizontal* radio buttons and
        the *Invert Zoom Direction* option.

    Dolly:
    :   *Dolly* zooming works similarly to *Continue* zooming except that zoom speed is constant.

Zoom Axis
:   The axis of the mouse to use for zooming.

    Vertical:
    :   Moving up zooms out and moving down zooms in.

    Horizontal:
    :   Moving left zooms in and moving right zooms out.

Zoom to Mouse Position
:   When enabled, the mouse pointer position becomes the focus point of zooming instead of the 2D window center.
    Helpful to avoid panning if you are frequently zooming in and out.

Invert Zoom Direction – Mouse
:   Inverts the Zoom direction for *Dolly* and *Continue* zooming.

Invert Zoom Direction – Wheel
:   Inverts the direction of the mouse wheel zoom.
user: Explain Make Parent without Inverse in complete detail according to the official Blender documentation.

assistant: This sets the parent, and then resets the *Parent Inverse* matrix and the object’s local location.
As a result, the object will move to the location of the parent, but keep its rotation and scale.

Keep Transform
:   The object’s current world transform (so its absolute location, rotation and scale in the world) is computed.
    The new parent is set, and then the local transform values are set in such a way that after setting
    the new parent the object is still at its previous world transform.
user: Give a detailed overview of GeometryNodeDistributePointsOnFaces(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeDistributePointsOnFaces(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.GeometryNodeDistributePointsOnFaces(*GeometryNode*)
:   Generate points spread out on the surface of a mesh

    distribute_method
    :   Method to use for scattering points

        - `RANDOM`
          Random – Distribute points randomly on the surface.
        - `POISSON`
          Poisson Disk – Distribute the points randomly on the surface while taking a minimum distance between points into account.

        Type:
        :   enum in [`'RANDOM'`, `'POISSON'`], default `'RANDOM'`

    use_legacy_normal
    :   Output the normal and rotation values that have been output before the node started taking smooth normals into account

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

assistant: # Gizmos

[image reference removed]

Grid with gizmo in the 3D viewport.

Gizmos allow changing inputs of Geometry Nodes directly in the 3D viewport.
This is often more intuitive than controlling the inputs in the modifier or node editor.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`RenderViews.active`](bpy.types.RenderViews.html#bpy.types.RenderViews.active "bpy.types.RenderViews.active") - [`RenderViews.new`](bpy.types.RenderViews.html#bpy.types.RenderViews.new "bpy.types.RenderViews.new") - [`RenderViews.remove`](bpy.types.RenderViews.html#bpy.types.RenderViews.remove "bpy.types.RenderViews.remove") | - [`RenderSettings.stereo_views`](bpy.types.RenderSettings.html#bpy.types.RenderSettings.stereo_views "bpy.types.RenderSettings.stereo_views") - [`RenderSettings.views`](bpy.types.RenderSettings.html#bpy.types.RenderSettings.views "bpy.types.RenderSettings.views") |
user: Give a detailed overview of Movie Clip Node: syntax, arguments, return values, common patterns.

assistant: # Movie Clip Node

[image reference removed]

This node is a special node that uses some of the values taken from
footage cameras and trackings and link them to the output.
It is possible to load image sequences, but only Image and Alpha values
will be available, because the other outputs will not have any values
associated with them.
When a tracked clip is chosen, Blender will fulfill the outputs using
internal values taken from the tracking. So the controls for
start and end frames will be defined in the Movie Clip editor.
user: Show practical ways to work with DynamicPaintCanvasSettings(bpy_struct) in a Blender add-on or script – include code.

assistant: # DynamicPaintCanvasSettings(bpy_struct)

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

*class* bpy.types.DynamicPaintCanvasSettings(*bpy_struct*)
:   Dynamic Paint canvas settings

    canvas_surfaces
    :   Paint surface list

        Type:
        :   [`DynamicPaintSurfaces`](bpy.types.DynamicPaintSurfaces.html#bpy.types.DynamicPaintSurfaces "bpy.types.DynamicPaintSurfaces") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`DynamicPaintSurface`](bpy.types.DynamicPaintSurface.html#bpy.types.DynamicPaintSurface "bpy.types.DynamicPaintSurface"), (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