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

assistant: # MeshPolygons(bpy_struct)

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

*class* bpy.types.MeshPolygons(*bpy_struct*)
:   Collection of mesh polygons

    active
    :   The active face for this mesh

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

    add(*count*)
    :   add

        Parameters:
        :   **count** (*int in* *[**0**,* *inf**]*) – Count, Number of polygons to add

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

assistant: Corner Index
:   The geometry-wide index of the selected corner. You can pass this to the
    [Evaluate at Index Node](../../utilities/field/evaluate_at_index.xhtml) or the
    [Sample Index Node](../../geometry/sample/sample_index.xhtml) (with the domain set to Face Corner)
    to retrieve details about the corner.

    If the edge has no connected corners, *Corner Index* will be zero.

Total
:   The number of faces (not face corners!) connected to the edge.
user: What is GeometryNodeDistributePointsInGrid(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeDistributePointsInGrid(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.GeometryNodeDistributePointsInGrid(*GeometryNode*)
:   Generate points inside a volume grid

    mode
    :   Method to use for scattering points

        - `DENSITY_RANDOM`
          Random – Distribute points randomly inside of the volume.
        - `DENSITY_GRID`
          Grid – Distribute the points in a grid pattern inside of the volume.

        Type:
        :   enum in [`'DENSITY_RANDOM'`, `'DENSITY_GRID'`], default `'DENSITY_RANDOM'`

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

assistant: |  |  |
| --- | --- |
| - [`ActionChannelbag.groups`](bpy.types.ActionChannelbag.html#bpy.types.ActionChannelbag.groups "bpy.types.ActionChannelbag.groups") - [`ActionChannelbagGroups.new`](bpy.types.ActionChannelbagGroups.html#bpy.types.ActionChannelbagGroups.new "bpy.types.ActionChannelbagGroups.new") | - [`ActionChannelbagGroups.remove`](bpy.types.ActionChannelbagGroups.html#bpy.types.ActionChannelbagGroups.remove "bpy.types.ActionChannelbagGroups.remove") - [`FCurve.group`](bpy.types.FCurve.html#bpy.types.FCurve.group "bpy.types.FCurve.group") |
user: Explain ShaderNodeHairInfo(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeHairInfo(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.ShaderNodeHairInfo(*ShaderNode*)
:   Retrieve hair curve information

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

assistant: # Edge Slide

Slides one or more edges across adjacent faces with a few restrictions involving the selection
of edges (i.e. the selection *must* define a valid loop, see below).

Even `E`
:   Forces the edge loop to match the shape of the adjacent edge loop.
    You can flip to the opposite vertex using `F`.

Flipped `F`
:   When Even mode is active, this flips between the two adjacent edge loops the active edge loop will match.

Clamp `Alt` or `C`
:   Toggle clamping the slide within the edge extents.

Factor
:   Determines the amount of slide performed.
    Negative values correspond to slides toward one face, while positive ones, refer to the other one.
    It is also displayed in the 3D Viewport footer.

Mirror Editing
:   Lets you propagate the operation to the symmetrical elements of the mesh (if present, in local X direction).

Correct UVs
:   Corrects the corresponding UV coordinates, if these exist, to avoid image distortions.
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Face Index
:   The geometry-wide index of the face which the corner belongs to.

Index in Face
:   The face-local index of the corner. This is 0 for the first corner of the face,
    1 for the next corner, and so on up to (number of corners - 1) for the last corner.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [[image reference removed]](../../../_images/modeling_modifiers_deform_cast_panel.png)

The Cast modifier.

Shape
:   Menu to choose target shape of the projection: *Sphere*, *Cylinder* or *Cuboid*.

Axis
:   Toggle buttons to enable/disable the modifier in the X, Y, Z axes directions
    (X and Y only for *Cylinder* cast type, since the Z axis remains unaffected).

Factor
:   The factor to control blending between original and cast vertex positions.

    It is a linear interpolation: 0.0 gives original coordinates (i.e. modifier has no effect),
    1.0 casts to the target shape.

    Values below 0.0 or above 1.0 exaggerate the deformation, sometimes in interesting ways.

Radius
:   If nonzero, this radius defines a sphere of influence.
    Vertices outside it are not affected by the modifier.

Size
:   Alternative size for the projected shape. If zero,
    it is defined by the initial shape and the control object, if any.

Size from Radius
:   If activated, calculate *Size* from *Radius*, for smoother results.

Vertex Group
:   If set, restrict the effect to the only vertices in that vertex group.
    This allows selective, real-time casting, by painting vertex weights.

    Invert
    :   Inverts the influence of the selected vertex group, meaning that the group
        now represents vertices that will not be deformed by the modifier.

        The setting reverses the weight values of the group.

Object
:   The name of an object to control the effect.
    The location of this object’s origin defines the center of the projection.
    Also, its size and rotation transform the projected vertices.
user: Give a detailed overview of GeometryNodeTool3DCursor(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeTool3DCursor(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.GeometryNodeTool3DCursor(*GeometryNode*)
:   The scene’s 3D cursor location and rotation

    *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: Explain Interpolate Hair Curves in complete detail according to the official Blender documentation.

assistant: # Interpolate Hair Curves

The *Interpolate Hair Curves* node generates new hair curves by interpolating existing *guide* curves
on a surface mesh.
It allows for efficient grooming workflows where a small number of guide curves define the overall
shape, and the node fills in additional interpolated curves to create a dense, detailed hair system.

For simpler duplication-based setups, the
[Duplicate Hair Curves](duplicate_hair_curves.xhtml)
node provides a lighter-weight alternative that may perform faster.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Image
:   Standard color input.

Minimum
:   Determines the lowest values that are considered foreground.
    (Which is supposed to be – relatively – light: from this value to 1.0.)

Maximum
:   Determines the highest values that are considered to be background objects.
    (Which is supposed to be – relatively – dark: from 0.0 to this value.)
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

Limit Distance constraint.

[Target](../interface/common.html#rigging-constraints-interface-common-target)
:   The object or bone to stay close to/keep away from.

Distance
:   The limit distance, i.e. the radius of the constraining sphere. It’s calculated
    automatically when selecting the first target.

    (Reset Distance)
    :   Set the *Distance* to the current distance between owner and target.

Clamp Region
:   How to constrain the owner relative to the spherical boundary:

    Inside:
    :   Keep the owner trapped within the sphere.

    Outside:
    :   Prevent the owner from entering the sphere.

    On Surface:
    :   Constrain the owner to the surface of the sphere.

Affect Transform
:   When the owner is manually moved around, restrict not just its
    [visual](../introduction.html#constraint-visual-transform) position but also its
    *Location* in the [Properties Editor](../../../editors/properties_editor.html)’s *Transform* panel.

[Target/Owner](../interface/common.html#rigging-constraints-interface-common-space)
:   The spaces for retrieving the position of the target and for applying the constrained result to the owner.

[Influence](../interface/common.html#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Mouse X
:   The region-space mouse X location, in pixels, increasing from 0 at the left.

Mouse Y
:   The region-space mouse Y location, in pixels, increasing from 0 at the bottom.

Region Width
:   The total X size of the [region](../../../../interface/window_system/regions.xhtml) in pixels.

Region Height
:   The total Y size of the [region](../../../../interface/window_system/regions.xhtml) in pixels.
user: How do I use Texture in Blender? Include parameters, examples, warnings and best practices.

assistant: # Texture

You can use a *Texture* force field to create an arbitrarily complicated force field,
which force in the three directions is color coded. Red is coding for the X axis,
green for the Y axis and blue for the Z axis
(like the color of the coordinate axes in the 3D Viewport). A value of 0.5 means no force,
a value larger than 0.5 acceleration in negative axis direction (like -Z),
a value smaller than 0.5 acceleration in positive axis direction (like +Z).
user: Provide the full official documentation entry for Installing Dependencies, preserving all code examples.

assistant: Install those packages or make sure you have them in your system.

- [PIP](https://pip.pypa.io/en/latest/installing/)
- [Git](https://git-scm.com/download/mac)
- [Git LFS](https://git-lfs.com)

When using [Homebrew](https://brew.sh), run the following commands in the terminal:

```
python3 -m ensurepip
brew install git git-lfs
git lfs install
```
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

The creation of a 3D scene needs at least three key components: Models, materials and lights.
In this part, the first of these is covered, that being modeling.
Modeling is simply the art and science of creating a surface that either mimics the shape
of a real-world object or expresses your imagination of abstract objects.
user: What is Regions and how is it used in Blender Python scripting?

assistant: # Regions

Every Editor in Blender is divided into Regions.
Regions can have smaller structuring elements like
[tabs and panels](tabs_panels.xhtml)
with buttons, controls and widgets placed within them.

[image reference removed]

The regions of the 3D Viewport showing the Sidebar and
the Adjust Last Operation panel after adding a Cube.

Header (green), Main region (yellow), Toolbar (blue),
Sidebar (red) and Adjust Last Operation panel (pink).
user: Describe Math Types & Utilities (mathutils) from the Blender manual or Python API, including usage steps and snippets.

assistant:  :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzxz
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzy
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzyw
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzyx
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzyy
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzyz
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzz
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzzw
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzzx
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzzy
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzzz
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Image/Color
:   Standard color input.

Hue
:   The hue rotation offset, from 0 (-180°) to 1 (+180°). Note that
    0 and 1 have the same result.

Saturation
:   A value of 0 removes color from the image, making it black-and-white.
    A value greater than 1.0 increases saturation.

Value
:   The value shift. 0 makes the color black, 1 keeps it the same, and higher
    values make it brighter.

Factor
:   The amount of influence the node exerts on the image.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Pivot constraint.

[Target](../interface/common.xhtml#rigging-constraints-interface-common-target)
:   The object or bone to use as the pivot point. Can be left empty,
    in which case the pivot point is either relative to the constraint owner itself
    or not relative to anything (fixed in space).

Use Relative Offset No Target set
:   Whether the *Pivot Point* coordinates are relative to the constraint owner
    or absolute in the world. If a *Target* is set, the coordinates are always relative.

Pivot Point X, Y, Z
:   The coordinates of the pivot point.

Rotation Range
:   Euler axis and direction for which the constraint should be active.

    Always:
    :   Apply pivoting for every possible owner rotation.

    -X/-Y/-Z Rotation:
    :   Only apply pivoting if the owner’s X/Y/Z rotation is negative or zero.

    X/Y/Z Rotation:
    :   Only apply pivoting if the owner’s X/Y/Z rotation is positive or zero.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Explain Bounce Control in complete detail according to the official Blender documentation.

assistant: The maximum number of light bounces can be controlled manually.
While ideally this should be infinite,
in practice a smaller number of bounces may be sufficient,
or some light interactions may be intentionally left out for faster convergence.
The number of diffuse reflection,
glossy reflection and transmission bounces can also be controlled individually.

Light paths are terminated probabilistically when specifying a minimum number of light bounces
lower than the maximum. In that case, paths longer than minimum will be randomly stopped when
they are expected to contribute less light to the image.
This will still converge to the same image, but renders faster while possibly being noisier.
user: Explain Gabor Texture Node in complete detail according to the official Blender documentation.

assistant: # Gabor Texture Node

[image reference removed]

The *Gabor Texture* node evaluates a Gabor noise at the input texture coordinates. Gabor noise is
visually characterized by random interleaved bands whose direction and width can be controlled.
Additionally, it can be used to create omnidirectional noise like the standard Noise Texture node,
but since it is more expensive to compute, using the Noise Texture node is probably the better
option in those cases. See the examples for more information.
user: Describe Additional Math Functions (bl_math) from the Blender manual or Python API, including usage steps and snippets.

assistant: # Additional Math Functions (bl_math)

Miscellaneous math utilities module.

bl_math.clamp(*value*, *min=0*, *max=1*)
:   Clamps the float value between minimum and maximum. To avoid
    confusion, any call must use either one or all three arguments.

    Parameters:
    :   - **value** (*float*) – The value to clamp.
        - **min** (*float*) – The minimum value, defaults to 0.
        - **max** (*float*) – The maximum value, defaults to 1.

    Returns:
    :   The clamped value.

    Return type:
    :   float

bl_math.lerp(*from_value*, *to_value*, *factor*)
:   Linearly interpolate between two float values based on factor.

    Parameters:
    :   - **from_value** (*float*) – The value to return when factor is 0.
        - **to_value** (*float*) – The value to return when factor is 1.
        - **factor** (*float*) – The interpolation value, normally in [0.0, 1.0].

    Returns:
    :   The interpolated value.

    Return type:
    :   float

bl_math.smoothstep(*from_value*, *to_value*, *value*)
:   Performs smooth interpolation between 0 and 1 as value changes between from and to values.
    Outside the range the function returns the same value as the nearest edge.

    Parameters:
    :   - **from_value** (*float*) – The edge value where the result is 0.
        - **to_value** (*float*) – The edge value where the result is 1.
        - **factor** (*float*) – The interpolation value.

    Returns:
    :   The interpolated value in [0.0, 1.0].

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

assistant: # Skin Resize

This tool is used to set a skin radius per vertex when using
a [Skin Modifier](../../../../modifiers/generate/skin.html).
Non-uniform scaling of the X and Y axes is accessible by the usual axis locking
with `X` or `Y`. The radius can also be adjusted in the *Transform* panel of
the Sidebar, in the 3D Viewport. The mean radius of all vertices can be previewed
in the 3D Viewport as a dashed circle around a vertex.

[image reference removed]

Simple creature, made with only the Skin and Subdivision Surface modifiers.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Curve
:   Standard geometry input, containing curves.

Selection
:   Whether or not to change the value on each control point. True values mean the value will be changed,
    false values mean the value will remain the same.

Radius
:   The radius value for each control point.
user: Give a detailed overview of Toolbar Selection Tools: syntax, arguments, return values, common patterns.

assistant: All the Toolbar selection tools behave the same when clicking an item: they select it
(and deselect any previously selected items). If you hold `Shift` while clicking,
the item will be added to the selection (if it’s not selected) or removed from the selection
(if it is selected).

What makes the tools different is what happens when you drag.

### Tweak

Dragging an item will move it around.

### Select Box

Dragging will create a rectangle, and select all the items that are partially or completely inside it
once you release. (Any other items will be deselected.)

Holding `Shift` while dragging will add the items to the selection.
Holding `Ctrl` will remove them.

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

Select Box example (Edit Mode).

|  |  |  |
| --- | --- | --- |
| <../_images/interface_selecting_border-select1.png>   Start. | <../_images/interface_selecting_border-select2.png>   Selecting vertices. | <../_images/interface_selecting_border-select3.png>   Complete. |

### Select Circle

Dragging will select all the items which the circle passed over.
Items which you didn’t pass over will be deselected.

Holding `Shift` while dragging will add the items to the selection.
Holding `Ctrl` will remove them.

You can change the radius of the circle in the tool settings (which can be found
in the area header, the Tool tab of the Sidebar `N`, or the Active Tool tab
of the [Properties editor](../editors/properties_editor.html)).

Select Circle example (Edit Mode).

|  |  |  |
| --- | --- | --- |
| <../_images/interface_selecting_circle-select1.png>   Start. | <../_images/interface_selecting_circle-select2.png>   Selecting vertices. | <../_images/interface_selecting_circle-select3.png>   Complete. |

### Select Lasso

Dragging will create a freeform shape, and select all the items inside it once you release.
(Any other items will be deselected.)

Holding `Shift` while dragging will add the items to the selection.
Holding `Ctrl` will remove them.

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

Select Lasso example (Edit Mode).

|  |  |  |
| --- | --- | --- |
| <../_images/interface_selecting_lasso-select1.png>   Start. | <../_images/interface_selecting_lasso-select2.png>   Selecting vertices. | <../_images/interface_selecting_lasso-select3.png>   Complete. |

### Selection Modes

Each of the Toolbar selection tools has a mode to configure
how it interacts with existing selections.
Note that not every tool supports all of these modes.

Set
:   Sets a new selection (the previous selection is discarded).
    This is the default.

Extend
:   Adds newly selected items to the existing selection.

Subtract
:   Removes newly selected items from the existing selection.

Invert `Ctrl`-`I`
:   Inverts the selection (unselected items become selected and vice versa).

Intersect
:   Selects items that intersect with the existing selection.
user: Describe FunctionNodeAlignRotationToVector(FunctionNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # FunctionNodeAlignRotationToVector(FunctionNode)

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"), [`FunctionNode`](bpy.types.FunctionNode.html#bpy.types.FunctionNode "bpy.types.FunctionNode")

*class* bpy.types.FunctionNodeAlignRotationToVector(*FunctionNode*)
:   Orient a rotation along the given direction

    axis
    :   Axis to align to the vector

        - `X`
          X – Align the X axis with the vector.
        - `Y`
          Y – Align the Y axis with the vector.
        - `Z`
          Z – Align the Z axis with the vector.

        Type:
        :   enum in [`'X'`, `'Y'`, `'Z'`], default `'X'`

    pivot_axis
    :   Axis to rotate around

        - `AUTO`
          Auto – Automatically detect the best rotation axis to rotate towards the vector.
        - `X`
          X – Rotate around the local X axis.
        - `Y`
          Y – Rotate around the local Y axis.
        - `Z`
          Z – Rotate around the local Z axis.

        Type:
        :   enum in [`'AUTO'`, `'X'`, `'Y'`, `'Z'`], default `'AUTO'`

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

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

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

    [image reference removed]

    From left to right: Sphere with a UV-mapped texture.
    Small spheres instanced to the faces of the textured sphere using
    [instancing from faces](../../../scene_layout/object/properties/instancing/faces.xhtml).
    Small spheres with *From Instancer* enabled, using the UV map of the large sphere.
user: Describe Custom Function - Square Value from the Blender manual or Python API, including usage steps and snippets.

assistant: Create a custom function to get the square of a value (i.e. *value*2).
Adding the function to the *Driver Namespace* allows it to be used from driver expressions.
The *Driver Namespace* has a list of built-in functions for use in driver expressions,
as well as constants such as π and e.
These can be inspected via the Python Console:

```
>>> bpy.app.driver_namespace[' <tab>
                              acos']
                              acosh']
                              asin']
                              asinh']
                              atan']
                              ...
```

To add a new function to the *Driver Namespace*, the function itself needs to be implemented
and then added to the `bpy.app.driver_namespace`.

1. Add the following to the Text Editor inside Blender and press *Run Script*.

   ```
   import bpy

   def square(val):
      """Returns the square of the given value"""
      return val * val

   # Add function to driver_namespace.
   bpy.app.driver_namespace['square'] = square
   ```
2. Add a driver with a *Scripted Expression* such as `square(frame)`.
3. Observe the effect when scrubbing the timeline.

There are more custom function examples available in Blender’s Text Editor
Templates ‣ Python ‣ Driver Functions.
Since [Simple Expressions](drivers_panel.xhtml#drivers-simple-expressions) cannot access
custom functions, using them only makes sense for complex computations.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: Transition
:   The type of transition used.

    Single
    :   Reveals the next strip by uncovering it in a straight line moving across the image.

    Double
    :   Similar to *Single*, but uses two lines either starting from the middle of the image or the outside.
        Like the blink of an eye.

    Iris
    :   Reveals the next strip through an expanding (or contracting) circle.
        Like the aperture of a camera or pupil of an eye.
        You can blur the transition, so it looks like ink bleeding through a paper.

    Clock
    :   Like the hands of an analog clock, it sweeps clockwise or (if Wipe In is enabled)
        counterclockwise from the 9:00 position. As it sweeps, it reveals the next strip.

Direction
:   Controls whether to fade *In* or *Out*.

Blur Width
:   The width of the blur used to blur the transition.

Angle
:   Controls the angle of the line for *Single* and *Double* transition types.

Default Fade
:   Automatically calculates a linear fade over the length of the strip.

    Effect Fader
    :   Allows you to manually [keyframe](../../../../../animation/keyframes/index.xhtml) a custom fade.
        This can be used with different [easings](../../../../../editors/graph_editor/fcurves/properties.xhtml#editors-graph-fcurves-settings-easing)
        to fine-tune the fade in/out.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Island Index
:   The index of each vertex’s island. Indices are decided based on the
    lowest vertex index contained in each island.

Island Count
:   The total number of mesh islands. This is a single value, and does not vary per element.
user: Describe GeometryNodeInputActiveCamera(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeInputActiveCamera(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.GeometryNodeInputActiveCamera(*GeometryNode*)
:   Retrieve the scene’s active camera

    *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 SpaceDopeSheetOverlay(bpy_struct), preserving all code examples.

assistant: # SpaceDopeSheetOverlay(bpy_struct)

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

*class* bpy.types.SpaceDopeSheetOverlay(*bpy_struct*)
:   show_overlays
    :   Display overlays

        Type:
        :   boolean, default True

    show_scene_strip_range
    :   When using scene time synchronization in the sequence editor, display the range of the current scene strip

        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: What is Decimate Modifier and how is it used in Blender Python scripting?

assistant: # Decimate Modifier

The *Decimate* modifier allows you to reduce the vertex/face count of a mesh with minimal shape changes.

This is not usually used on meshes which have been created by modeling carefully and economically
(where all vertices and faces are necessary to correctly define the shape).
But if the mesh is the result of complex modeling,
sculpting and/or applied [Subdivision Surface](subdivision_surface.html)/
[Multiresolution](multiresolution.html) modifiers,
the *Decimate* one can be used to reduce the polygon count for a performance increase,
or simply remove unnecessary vertices and edges.

Unlike the majority of existing modifiers, this one does not allow
you to visualize your changes in Edit Mode.

The modifier displays the number of remaining faces as a result of the *Decimate* modifier.
user: What is CurveMapPoints(bpy_struct) and how is it used in Blender Python scripting?

assistant: # CurveMapPoints(bpy_struct)

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

*class* bpy.types.CurveMapPoints(*bpy_struct*)
:   Collection of Curve Map Points

    new(*position*, *value*)
    :   Add point to CurveMap

        Parameters:
        :   - **position** (*float in* *[**-inf**,* *inf**]*) – Position, Position to add point
            - **value** (*float in* *[**-inf**,* *inf**]*) – Value, Value of point

        Returns:
        :   New point

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

    remove(*point*)
    :   Delete point from CurveMap

        Parameters:
        :   **point** ([`CurveMapPoint`](bpy.types.CurveMapPoint.html#bpy.types.CurveMapPoint "bpy.types.CurveMapPoint"), (never None)) – PointElement 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: Explain Frequently Asked Questions in complete detail according to the official Blender documentation.

assistant: ### Why is Blender unresponsive during rendering?

On older GPU generations, graphics cards can only either render or draw the user interface.
This can make Blender unresponsive while it is rendering.
Heavy scenes can also make Blender unresponsive on newer GPUs,
when using a lot of memory or executing expensive shaders, however this is generally less of a problem.

The only complete solution for this is to use a dedicated GPU for rendering, and another for display.

### Why does a scene that renders on the CPU not render on the GPU?

There may be multiple causes,
but the most common one is that there is not enough memory on your graphics card.
Typically, the GPU can only use the amount of memory that is on the GPU
(see [Would multiple GPUs increase available memory?](#would-multiple-gpus-increase-available-memory) for more information).
This is usually much smaller than the amount of system memory the CPU can access.
With CUDA, OptiX, HIP and Metal devices, if the GPU memory is full Blender will automatically
try to use system memory. This has a performance impact, but will usually still result in a faster render
than using CPU rendering.

### Can multiple GPUs be used for rendering?

Yes, go to Preferences ‣ System ‣ Compute Device Panel, and configure it as you desire.

### Would multiple GPUs increase available memory?

Typically, no, each GPU can only access its own memory.

The exception is NVIDIA GPUs connected with NVLink, where multiple GPUs can share memory at a small performance cost.
This can be enabled with [Distributed Memory Across Devices](../../editors/preferences/system.xhtml#prefs-system-cycles-distributive-memory)
in the preferences.

### What renders faster?

This varies depending on the hardware used. Different technologies also have different compute times
depending on the scene tested. For the most up to date information on the performance of different devices,
browse the [Blender Open Data](https://opendata.blender.org/) resource.
user: How do I use NDOFMotionEventData(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NDOFMotionEventData(bpy_struct)

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

*class* bpy.types.NDOFMotionEventData(*bpy_struct*)
:   NDOF motion data for window manager events

    progress
    :   Indicates the gesture phase

        Type:
        :   enum in [`'STARTING'`, `'IN_PROGRESS'`, `'FINISHING'`], default `'STARTING'`, (readonly)

    rotation
    :   Axis-angle rotation of this motion event. The vector magnitude is the angle where 1.0 represents 360 degrees. The angle is typically scaled by the time-delta before use.

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

    time_delta
    :   Time since previous motion event (in seconds)

        Type:
        :   float in [-inf, inf], default 0.0, (readonly)

    translation
    :   The translation of this motion event. The range on each axis is [-1 to 1], before being multiplied by the sensitivity preference. This is typically scaled by the time-delta before use.

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], default (0.0, 0.0, 0.0), (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: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The Build modifier.

Mode
:   Determines how many strokes are being animated at a time.

    Sequential:
    :   Strokes appear/disappear one after the other, but only a single one changes at a time.

    Concurrent:
    :   Multiple stroke appear/disappear at a time.

    Additive:
    :   Builds only the strokes that are new compared to last keyframe.
        The assumption is Additive Drawing was used so that the shared strokes are the same.

Transition *(in Sequential and Concurrent Mode)*
:   Determines the animation type to build the strokes.

    Grow:
    :   Shows points in the order they occur in each stroke, from first to last stroke.
        (Simulating lines being drawn.)

    Shrink:
    :   Hide points from the end of each stroke to the start, from last to first stroke.
        (Simulating lines being erased.)

    Vanish:
    :   Hide points in the order they occur in each stroke, from first to last stroke.
        (Simulating ink fading or vanishing after getting drawn.)

Timing
:   The way you want to time the building of the strokes.

    Natural Drawing Speed:
    :   Use the recorded speed of the stylus when the strokes were drawn.
        Only available in Sequential and Additive Mode.

        Speed Factor
        :   The recorded speed is multiplied by this value.

        Maximum Gap
        :   The maximum gap between strokes in seconds.

    Number of Frames:
    :   Set a fixed maximum number of frames for the build animation.
        (Unless another Grease Pencil keyframe occurs before this time has elapsed.)

        Frames
        :   The maximum number of frames used.

        Delay
        :   Number of frames after each Grease Pencil keyframe before the modifier has any effects.

    Percentage Factor:
    :   Manually set a percentage factor to control the amount of the strokes that are visible.

        Factor
        :   The factor from 0 to 1.

    Time Alignment:
    :   Only available in Concurrent Mode.

        Align Start
        :   All stroke start at the same time (i.e. shorter strokes finish earlier).

        Align End
        :   All stroke end at the same time (i.e. shorter strokes start later).

Object
:   Use the distance to an object to define the order in which strokes appear.

### Custom Range

If enabled, only modify strokes during the specified frame range.

Start, End
:   Determines the start and end frame for the build effect.

### Fade

Factor
:   Defines how much the stroke is fading in/out.

Thickness
:   How much strength fading is applied to the stroke’s thickness.

Opacity
:   How much strength fading applies to the stroke’s opacity.

Weight Output
:   Assign a weight value to points that have started/finished the fade.

### Influence Filters

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Provide the full official documentation entry for Actions, preserving all code examples.

assistant: # Actions

*Actions* are Blender’s container for animation data. For example, when you
animate the location of an object, that animation is stored in an action rather
than directly on the object itself. The object then uses the action to get
animated, much the same way that a mesh uses a material to get shaded. All
animatable [data-blocks](../glossary/index.xhtml#term-Data-Block)
([objects](../scene_layout/object/introduction.xhtml),
[meshes](../modeling/meshes/introduction.xhtml),
[materials](../render/materials/introduction.xhtml), etc.) are animated this way:
they don’t store their own animation data, but instead use an action that stores
the animation data for them.

Actions are also data-blocks themselves, and therefore can be easily appended or
linked into other blend files. This lets actions be used not just for storage,
but also for organizing and reusing animation data. For example, if you’re
building a library of animations (run cycles, jumps, idling, etc.), each
animation can go into its own action, which can then be conveniently linked or
exported as a distinct animation.