PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with Object Gizmos in a Blender add-on or script – include code.

assistant: Object Gizmos allow mouse-controlled translation, rotation and scaling in the 3D Viewport.
While they’re called “object” gizmos in the popover, they also apply to other transformable
elements such as mesh vertices.

There is a separate gizmo for each operation.
Each gizmo can be used separately or in combination with the others.

A gizmo always has three color-coded axes: X (red), Y (green), and Z (blue).
You can drag an axis with `LMB` to transform along it. The Move and Scale gizmos
additionally have small colored squares for transforming along two axes in one go.

Various modifier keys can be used:

- Holding `Ctrl` at any time will toggle [snapping](../controls/snapping.xhtml)
  and also make rotation and scaling work in coarse increments.
- Holding `Shift` *after* pressing `LMB` will do the opposite of the above, “slowing down”
  the transformation relative to mouse movement to allow finer adjustments.
- Holding `Shift` *before* pressing `LMB` will perform the transformation in the plane
  that’s perpendicular to the clicked axis. See [Plane Locking](../../../scene_layout/object/editing/transform/control/axis_locking.xhtml#view3d-transform-plane-lock).

The Gizmos popover has the following settings for object gizmos:

Orientation
:   The orientation to use for the gizmo. *Default* means to use the viewport’s
    [Transform Orientation](../controls/orientation.xhtml).
    The other options override it.

Move
:   Show the gizmo to control the location.
    Dragging the small white circle allows free movement in the viewing plane.

Rotate
:   Show the gizmo to control the rotation.
    Dragging the large white circle allows rotation around the viewing direction.
    Dragging the translucent white disc within that circle (only visible when
    hovering over the gizmo) allows [trackball rotation](../../../scene_layout/object/editing/transform/rotate.xhtml#view3d-transform-trackball).

Scale
:   Show the gizmo to control the scale.
    Dragging the area between the small and large white circles scales along all three axes.

The latter three options are also available in a pie menu
if you have the *Grave Accent / Tilde Action* in the
[Keymap Preferences](../../preferences/keymap.xhtml) set to *Gizmos*.

|  |  |  |  |
| --- | --- | --- | --- |
| ../../../_images/editors_3dview_display_gizmo_options-translate.png   Move. | ../../../_images/editors_3dview_display_gizmo_options-rotate.png   Rotate. | ../../../_images/editors_3dview_display_gizmo_options-scale.png   Scale. | ../../../_images/editors_3dview_display_gizmo_options-all.png   Combination. |
user: Provide the full official documentation entry for Split Concave Faces, preserving all code examples.

assistant: Splits any selected [concave](../../../../glossary/index.html#term-Concave-Face) faces so that only convex ones remain.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_cleanup_split-concave-before.png   Original mesh. | ../../../../_images/modeling_meshes_editing_mesh_cleanup_split-concave-after.png   Result of Split Concave Faces. |
user: Give a detailed overview of How to Bundle Wheels: syntax, arguments, return values, common patterns.

assistant: Python wheels (`*.whl`) can be bundled using the following steps.

Downloading Wheels
:   Download the wheel to the directory `./wheels/`.

    For wheels that are platform independent this example downloads `jsmin`:

    ```
    pip wheel jsmin -w ./wheels
    ```

    For wheels that contain binary compiled files, wheels for all supported platforms should be included:

    This example downloads `pillow` - the popular image manipulation module.

    ```
    pip download pillow --dest ./wheels --only-binary=:all: --python-version=3.11 --platform=macosx_11_0_arm64
    pip download pillow --dest ./wheels --only-binary=:all: --python-version=3.11 --platform=manylinux_2_28_x86_64
    pip download pillow --dest ./wheels --only-binary=:all: --python-version=3.11 --platform=win_amd64
    ```

    The available platform identifiers are listed on
    [pillow’s download page](https://pypi.org/project/pillow/#files).

Update the Manifest
:   In `blender_manifest.toml` include the wheels as a list of paths, e.g.

    ```
    wheels = [
       "./wheels/pillow-10.3.0-cp311-cp311-macosx_11_0_arm64.whl",
       "./wheels/pillow-10.3.0-cp311-cp311-manylinux_2_28_x86_64.whl",
       "./wheels/pillow-10.3.0-cp311-cp311-win_amd64.whl",
    ]
    ```

    Now installing the package will extract the wheel into the extensions own `site-packages` directory.

Running
:   Once the extension has been installed you can check the module is being loaded by importing it in the
    Python console and printing it’s location:

    ```
    import PIL
    print(PIL.__file__)
    ```
user: Describe Toolbar from the Blender manual or Python API, including usage steps and snippets.

assistant: # Toolbar

Mesh Edit Mode tools:

[Select](../../../../interface/selecting.xhtml#tool-select-tweak)
:   Select or move.

    [Select Box](../../../../interface/selecting.xhtml#tool-select-box)
    :   Select geometry by dragging a box.

    [Select Circle](../../../../interface/selecting.xhtml#tool-select-circle)
    :   Select geometry by dragging a circle.

    [Select Lasso](../../../../interface/selecting.xhtml#tool-select-lasso)
    :   Select geometry by drawing a lasso.

Cursor
:   Change the location of the 3D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

    [Scale Cage](../../../../scene_layout/object/tools/scale_cage.xhtml#tool-scale-cage)
    :   Change the scale of an object by controlling its cage.

Transform
:   Tool to adjust the objects translation, rotations and scale.

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

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

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

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

[Measure](../../../../editors/3dview/toolbar/measure.xhtml#tool-measure)
:   Measure distances in the scene.

[Roll](../editing/bone_roll.xhtml#tool-bone-roll)
:   Rotates a bone around its local Y axis.

Bone Size

Extrude
:   Creates a new bone connected to the last selected joint.

    Extrude to Cursor
    :   Creates a new bone between the last selected joint and the mouse position.

Shear
user: How do I use Angular Velocity in Blender? Include parameters, examples, warnings and best practices.

assistant: Lets you configure if and how particles should spin over time.
*Dynamic* needs to be enabled for this to work.

Axis
:   The axis to spin around. If this is set to *Velocity*, *Horizontal*, or *Vertical*,
    particles will additionally spin to keep the same orientation relative to their
    direction of movement, even if *Amount* is zero.

    None
    :   Spinning is disabled.

    Velocity
    :   Spin around the particle’s velocity vector.

    Horizontal
    :   Spin around the axis that’s horizontal (lying in the global XY plane)
        and perpendicular to the particle’s velocity. Particles moving along the
        global Z axis won’t spin because no unique rotation axis exists in this case.

    Vertical
    :   Spin around the axis that’s perpendicular to both the particle’s velocity
        and the above *Horizontal* axis. Particles moving along the global Z axis
        won’t spin.

    Global X, Y, Z
    :   Spin around the chosen global axis.

    Random
    :   Spin around a random axis.

Amount
:   How fast to spin around the *Axis*.
user: Show practical ways to work with GpSculptPaint(Paint) in a Blender add-on or script – include code.

assistant: # GpSculptPaint(Paint)

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

*class* bpy.types.GpSculptPaint(*Paint*)
:   *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 Particle Edit Hair Brush Items in a Blender add-on or script – include code.

assistant: # Particle Edit Hair Brush Items

COMB:
:   Comb.

    Comb hairs.

SMOOTH:
:   Smooth.

    Smooth hairs.

ADD:
:   Add.

    Add hairs.

LENGTH:
:   Length.

    Make hairs longer or shorter.

PUFF:
:   Puff.

    Make hairs stand up.

CUT:
:   Cut.

    Cut hairs.

WEIGHT:
:   Weight.

    Weight hair particles.
user: What is Technical Details and how is it used in Blender Python scripting?

assistant: A more formal definition of a meta object can be given as a *directing structure* which can
be seen as the source of a static field. The field can be either positive or negative and
hence the field generated by neighboring directing structures can attract or repel.

The implicit surface is defined as the surface where the 3D field generated by
all the directing structures assume a given value. For example a meta ball,
whose directing structure is a point, generates
an isotropic (i.e. identical in all directions) field around it and
the surfaces at constant field value are spheres centered at the directing point.

*Meta* objects are nothing more than mathematical formula that perform logical operations on one another
(AND, OR), and that can be added and subtracted from each other.
This method is also called *Constructive Solid Geometry* (CSG).
Because of its mathematical nature, CSG uses little memory, but requires lots of processing power to compute.
user: Give a detailed overview of BoolAttribute(Attribute): syntax, arguments, return values, common patterns.

assistant: # BoolAttribute(Attribute)

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

*class* bpy.types.BoolAttribute(*Attribute*)
:   Geometry attribute that stores booleans

    data
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`BoolAttributeValue`](bpy.types.BoolAttributeValue.html#bpy.types.BoolAttributeValue "bpy.types.BoolAttributeValue"), (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Set Material Index Node in a Blender add-on or script – include code.

assistant: # Set Material Index Node

[image reference removed]

The *Set Material Index* node sets the material index for a geometry.

The node to get this data is the [Material Index](material_index.xhtml) node.
user: Provide the full official documentation entry for Selecting, preserving all code examples.

assistant: Click `LMB` on the marker’s triangle to select it.
Use `Shift`-`LMB` to select multiple markers.

In the Graph Editor, Dope Sheet, NLA Editor, Timeline, and Video Sequence Editor,
you can also select all markers with `A` while hovering the mouse over the marker row,
and apply selection tools on them like Box Select, etc.
(as usual, `LMB` to select, `RMB` to deselect).
The corresponding options are found in the Select menu of these editors.
user: Provide the full official documentation entry for Int2Attribute(Attribute), preserving all code examples.

assistant: # Int2Attribute(Attribute)

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

*class* bpy.types.Int2Attribute(*Attribute*)
:   Geometry attribute that stores 2D integer vectors

    data
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`Int2AttributeValue`](bpy.types.Int2AttributeValue.html#bpy.types.Int2AttributeValue "bpy.types.Int2AttributeValue"), (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Index
:   Index number of the particle (from 0 to number of particles).

Random
:   A random per-particle value in the range from 0 to 1.
    It can for example be used in combination with a color ramp, to randomize the particle color.

Age
:   Age of the particle in frames.

Lifetime
:   Total lifespan of the particle in frames.

Location
:   Location of the particle.

Size
:   Size of the particle.

Velocity
:   Velocity of the particle.

Angular Velocity
:   Angular velocity of the particle.
user: Give a detailed overview of Set Mesh Normal Node: syntax, arguments, return values, common patterns.

assistant: # Set Mesh Normal Node

[image reference removed]

The *Set Mesh Normal* node stores a normal vector for each mesh element.

This can be used to control shading appearance and influence subsequent operations that rely on surface normals.
user: How do I use Sampling in Blender? Include parameters, examples, warnings and best practices.

assistant: # Sampling

Sampling is the process of tracing rays from the camera into the scene and
bouncing them around until they reach a light source such as a Light object,
an emissive mesh, or the world background. The algorithm for this is known
as the integrator.

Viewport (Max) Samples
:   The number of paths to trace per pixel in the 3D Viewport
    (when using the *Rendered* [shading mode](../../../editors/3dview/display/shading.xhtml)).
    Setting this value to zero enables indefinite sampling.

Render (Max) Samples
:   The number of paths to trace per pixel in the final render.
    A higher number results in a cleaner image at the cost of a longer render time.

Time Limit
:   Stops rendering if the time exceeds the limit, even if the desired sample count
    hasn’t been reached yet. Setting this value to zero disables the limit.
user: Show practical ways to work with Group Output in a Blender add-on or script – include code.

assistant: Receives the outputs of the node group. You can have multiple of these nodes in your tree to keep it clean,
outputting each result right where it’s produced (rather than dragging long links all across your graph).

The output slots can be edited in the *Group* tab of the *Sidebar*.
user: Give a detailed overview of ForeachGeometryElementMainItem(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # ForeachGeometryElementMainItem(bpy_struct)

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

*class* bpy.types.ForeachGeometryElementMainItem(*bpy_struct*)
:   color
    :   Color of the corresponding socket type in the node editor

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

    name
    :   Type:
        :   string, default “”, (never None)

    socket_type
    :   Type:
        :   enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items), default `'FLOAT'`

    *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 Duplicate Elements Node in a Blender add-on or script – include code.

assistant: # Duplicate Elements Node

[image reference removed]

The *Duplicate Elements* node creates a new geometry with the specified elements
from the input duplicated an arbitrary number of times. The positions of elements
are not changed, so all of the duplicates will be at the exact same location.
user: Describe StringProperty(Property) from the Blender manual or Python API, including usage steps and snippets.

assistant: # StringProperty(Property)

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

*class* bpy.types.StringProperty(*Property*)
:   RNA text string property definition

    default
    :   String default value

        Type:
        :   string, default “”, (readonly, never None)

    length_max
    :   Maximum length of the string, 0 means unlimited

        Type:
        :   int in [0, inf], default 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: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

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

assistant: # Duplicate

This will create a visually-identical copy of the selected object(s).
The copy is created at the same position as the original object and
you are automatically placed in move mode. See the examples below.

This copy is a new object, which shares data-blocks with the original object
(by default, all the materials, textures, and F-Curves), but which has copied others,
like the mesh, for example. That is why this form of duplication is sometimes called “shallow link”,
because not all data-blocks are shared; some of them are “hard copied”!
user: Describe Editing Tools from the Blender manual or Python API, including usage steps and snippets.

assistant: # Editing Tools

[image reference removed]

[Select](../../../../interface/selecting.html#tool-select-tweak)
:   Select or moved.

    [Select Box](../../../../interface/selecting.html#tool-select-box)
    :   Select geometry by dragging a box.

    [Select Circle](../../../../interface/selecting.html#tool-select-circle)
    :   Select geometry by painting on it.

    [Select Lasso](../../../../interface/selecting.html#tool-select-lasso)
    :   Select geometry by drawing a lasso.

Cursor
:   Change the location of the 3D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

    [Scale Cage](../../../../scene_layout/object/tools/scale_cage.html#tool-scale-cage)
    :   Change the scale of an object by controlling its cage.

Transform
:   Tool to adjust the objects translation, rotations and scale.

[Pen](pen.html#tool-grease-pencil-edit-pen)
:   Tool for creating and modifying [Bézier](../../../../modeling/curves/structure.html#curve-spline-types) strokes.

Radius `Alt`-`S`
:   Expand or contract the thickness radius of the selected points.

Bend `Shift`-`W`
:   Bend selected points between the 3D cursor and the pointer.

Shear `Shift`-`Ctrl`-`Alt`-`S`
:   Shear selected points along the horizontal or vertical screen axis.

    To Sphere `Shift`-`Alt`-`S`
    :   Move selected points outward in a spherical shape around the selected strokes’ center.

[Interpolate](../../draw/tools/interpolate.html#tool-grease-pencil-draw-interpolate) `Ctrl`-`E`
:   Automatically create a breakdown keyframe between two normal keyframes.

Gradient
:   Draw a line to set the fill material gradient for the selected strokes.

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

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

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

    [Annotate Eraser](../../../../interface/annotate_tool.html#tool-annotate-eraser)
    :   Erase previous drawn annotations.
user: Provide the full official documentation entry for ThemeGradientColors(bpy_struct), preserving all code examples.

assistant: # ThemeGradientColors(bpy_struct)

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

*class* bpy.types.ThemeGradientColors(*bpy_struct*)
:   Theme settings for background colors and gradient

    background_type
    :   Type of background in the 3D viewport

        - `SINGLE_COLOR`
          Single Color – Use a solid color as viewport background.
        - `LINEAR`
          Linear Gradient – Use a screen space vertical linear gradient as viewport background.
        - `RADIAL`
          Vignette – Use a radial gradient as viewport background.

        Type:
        :   enum in [`'SINGLE_COLOR'`, `'LINEAR'`, `'RADIAL'`], default `'SINGLE_COLOR'`

    gradient
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    high_gradient
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Sets up a [Line Art Modifier](modifiers/generate/line_art.xhtml) for the active collection
by creating an “empty” Grease Pencil object with a Line Art modifier referencing each object in the collection.
user: Explain ExplodeModifier(Modifier) in complete detail according to the official Blender documentation.

assistant: # ExplodeModifier(Modifier)

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

*class* bpy.types.ExplodeModifier(*Modifier*)
:   Explosion effect modifier based on a particle system

    invert_vertex_group
    :   Invert vertex group influence

        Type:
        :   boolean, default False

    particle_uv
    :   UV map to change with particle age

        Type:
        :   string, default “”, (never None)

    protect
    :   Clean vertex group edges

        Type:
        :   float in [0, 1], default 0.0

    show_alive
    :   Show mesh when particles are alive

        Type:
        :   boolean, default True

    show_dead
    :   Show mesh when particles are dead

        Type:
        :   boolean, default True

    show_unborn
    :   Show mesh when particles are unborn

        Type:
        :   boolean, default True

    use_edge_cut
    :   Cut face edges for nicer shrapnel

        Type:
        :   boolean, default False

    use_size
    :   Use particle size for the shrapnel

        Type:
        :   boolean, default False

    vertex_group
    :   Type:
        :   string, default “”, (never None)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # ActionStrips(bpy_struct)

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

*class* bpy.types.ActionStrips(*bpy_struct*)
:   Collection of animation strips

    new(*\**, *type='KEYFRAME'*)
    :   Add a new strip to the layer. Currently a layer can only have one strip, with infinite boundaries.

        Parameters:
        :   **type** (enum in [`'KEYFRAME'`], (optional)) –

            Type, The type of strip to create

            - `KEYFRAME`
              Keyframe – Strip containing keyframes on F-Curves.

        Returns:
        :   Newly created animation strip

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

    remove(*anim_strip*)
    :   Remove the strip from the animation layer

        Parameters:
        :   **anim_strip** ([`ActionStrip`](bpy.types.ActionStrip.html#bpy.types.ActionStrip "bpy.types.ActionStrip")) – Animation Strip, The strip 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: How do I use Brush Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: ### General

### Unique

Plane Angle
:   The angle between the two planes of the brush, pressing `Ctrl` inverts the angle.

Dynamic Mode
:   When enabled, the angle is dynamically updated based on the surface under the brush.
    The *Plane Angle* then controls how much the angle will increase when applying pen pressure.
    When pressing `Ctrl`, it locks the plane angle to 0 degrees.

Show Cursor Preview
:   Displays a preview of the two planes
    and the angle they form during the stroke.
user: What is Importing and how is it used in Blender Python scripting?

assistant: Import geometry and curves to the OBJ format.

If there is a matching `.MTL` for the OBJ then its materials will be imported too.

### General

Scale
:   Value by which to scale the imported objects in relation to the world’s origin.

Clamp Bounding Box
:   OBJ-files often vary greatly in scale, this setting clamps the imported file to a fixed size.

Forward Axis, Up Axis
:   Since many applications use a different axis for ‘Up’, these are axis conversion for these settings,
    Forward and Up axes – By mapping these to different axes you can convert rotations
    between applications default up and forward axes.

    Blender uses Y Forward, Z Up (since the front view looks along the +Y direction).
    For example, it’s common for applications to use Y as the up axis, in that case -Z Forward, Y Up is needed.

### Options

Split By Object
:   Import each OBJ “object name” group (`o`) as a separate object.

Split By Group
:   Import each OBJ “object name” group (`g`) as a separate object.

Vertex Groups
:   Import OBJ groups as vertex groups.

Validate Meshes
:   Check the imported mesh for corrupt data and fix it if necessary.
    When disabled, erroneous data may cause crashes displaying or editing the meshes.
    This option will make the importing slower but is recommended, as data errors are not always obvious.

Detect Cyclic Curves
:   Joins curve endpoints if overlapping control points are detected (if disabled, no curves will be cyclic).

Path Separator
:   Character used to separate an object’s name into a hierarchical
    structure using [Collections](../../scene_layout/collections/index.html).

### Materials

Material Name Collision
:   Behavior when the name of an imported material conflicts with an existing material.

    Make Unique:
    :   Import each USD material as a unique Blender material.

    Reference Existing:
    :   If a material with the same name already exists, reference that instead of importing.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

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

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

Domain
:   The [attribute domain](../../attributes_reference.html#attribute-domains) used for evaluate the *Value* input.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Path
:   The path to the CSV file. The file must be structured with one row per point and values separated by a delimiter.

Delimiter
:   The character used to separate values within each row of the CSV file,
    such as a comma (,), semicolon (;), or tab character.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`ShaderNodeTexBrick.color_mapping`](bpy.types.ShaderNodeTexBrick.html#bpy.types.ShaderNodeTexBrick.color_mapping "bpy.types.ShaderNodeTexBrick.color_mapping") - [`ShaderNodeTexChecker.color_mapping`](bpy.types.ShaderNodeTexChecker.html#bpy.types.ShaderNodeTexChecker.color_mapping "bpy.types.ShaderNodeTexChecker.color_mapping") - [`ShaderNodeTexEnvironment.color_mapping`](bpy.types.ShaderNodeTexEnvironment.html#bpy.types.ShaderNodeTexEnvironment.color_mapping "bpy.types.ShaderNodeTexEnvironment.color_mapping") - [`ShaderNodeTexGabor.color_mapping`](bpy.types.ShaderNodeTexGabor.html#bpy.types.ShaderNodeTexGabor.color_mapping "bpy.types.ShaderNodeTexGabor.color_mapping") - [`ShaderNodeTexGradient.color_mapping`](bpy.types.ShaderNodeTexGradient.html#bpy.types.ShaderNodeTexGradient.color_mapping "bpy.types.ShaderNodeTexGradient.color_mapping") - [`ShaderNodeTexImage.color_mapping`](bpy.types.ShaderNodeTexImage.html#bpy.types.ShaderNodeTexImage.color_mapping "bpy.types.ShaderNodeTexImage.color_mapping") | - [`ShaderNodeTexMagic.color_mapping`](bpy.types.ShaderNodeTexMagic.html#bpy.types.ShaderNodeTexMagic.color_mapping "bpy.types.ShaderNodeTexMagic.color_mapping") - [`ShaderNodeTexNoise.color_mapping`](bpy.types.ShaderNodeTexNoise.html#bpy.types.ShaderNodeTexNoise.color_mapping "bpy.types.ShaderNodeTexNoise.color_mapping") - [`ShaderNodeTexSky.color_mapping`](bpy.types.ShaderNodeTexSky.html#bpy.types.ShaderNodeTexSky.color_mapping "bpy.types.ShaderNodeTexSky.color_mapping") - [`ShaderNodeTexVoronoi.color_mapping`](bpy.types.ShaderNodeTexVoronoi.html#bpy.types.ShaderNodeTexVoronoi.color_mapping "bpy.types.ShaderNodeTexVoronoi.color_mapping") - [`ShaderNodeTexWave.color_mapping`](bpy.types.ShaderNodeTexWave.html#bpy.types.ShaderNodeTexWave.color_mapping "bpy.types.ShaderNodeTexWave.color_mapping") |
user: Describe Sharp Edges from the Blender manual or Python API, including usage steps and snippets.

assistant: Similar to wall-thickness, sharp edges can form shapes that are too thin to be able to print.

Minimum/Maximum
:   Minimum/Maximum angle to display.

[[image reference removed]](../../_images/modeling_meshes_mesh-analysis_sharp-edges.png)

Sharp edges.
user: Describe Noise Texture Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Noise Texture Node

[image reference removed]

The *Noise Texture* node evaluates a fractal Perlin noise at the input texture coordinates.
It can be used for a single Perlin noise evaluation, or for combining multiple octaves
(layers) with increasingly finer detail.
user: Explain Volume to Mesh Node in complete detail according to the official Blender documentation.

assistant: # Volume to Mesh Node

[image reference removed]

The *Volume to Mesh* node generates a mesh on the “surface” of a volume.
The surface is defined by a threshold value.
All voxels with a larger value than the threshold are considered to be inside.
user: Show practical ways to work with Tool Settings in a Blender add-on or script – include code.

assistant: Depth
:   The initial depth (from the screen into the scene) used when placing the object.

    Surface:
    :   Start placing on the surface under the mouse cursor. If there is no surface, this does the
        same as *Cursor Plane*.

    Cursor Plane:
    :   Start placing on a plane that goes through the [3D Cursor](../3d_cursor.html)
        and is aligned according to the *Orientation* and *Plane Axis*.

    Cursor View:
    :   Start placing on a plane that goes through the 3D Cursor and is aligned to the view.

Orientation
:   The new object’s orientation – a set of three axes, out of which *Plane Axis* chooses one.

    Surface:
    :   The object uses the normal orientation of the surface under the mouse cursor.
        If there is no surface, this does the same as *Default*.

    Default:
    :   The object uses the default [Transform Orientation](../controls/orientation.html).

Snap To
:   The target to use while [Snapping](../controls/snapping.html).

    Geometry:
    :   Snap to all types of geometry (vertices, edges, and faces).

    Default:
    :   Snap to the target defined in the global snapping options.

Plane Axis
:   Which of the three *Orientation* axes (X, Y or Z) is “up” for the object.
    The object’s base will be perpendicular to this axis.

Auto Axis
:   Rather than using the *Orientation* axis indicated by *Plane Axis*,
    use the one that’s closest to the viewport’s viewing direction
    (when not hovering over a surface).

Base

Origin
:   How the base is defined.

    Edge:
    :   The base is defined from one corner to the opposing corner.

    Center:
    :   The base is defined from the centerpoint to a corner.

Aspect
:   Whether the base has a free or fixed aspect ratio.

    Free:
    :   The width and depth of the base can be chosen independently.

    Fixed:
    :   The width and depth of the base are forced to be equal.

Height

Origin
:   How the height is defined.

    Edge:
    :   The base becomes the bottom, after which you define the top.

    Center:
    :   The base becomes the center, after which you define the top.

Aspect
:   Whether the object’s side has a free or fixed aspect ratio.

    Free:
    :   The height can be chosen independently of the base.

    Fixed:
    :   The height is forced to be equal to the largest side of the base.
user: Provide the full official documentation entry for Faces by Edges, preserving all code examples.

assistant: *Faces by Edges* is similar to the *Rip* tool. When two or more touching interior edges,
or a border edge is selected, a hole will be created,
and the selected edges will be duplicated to form the border of the hole.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_split_edges-before.png   Selected edges. | ../../../../_images/modeling_meshes_editing_mesh_split_edges-after.png   Adjacent face moved to reveal hole left by split. |
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Quadratic
:   Quadratic light falloff; this will leave strength unmodified if smooth is 0.0 and corresponds to reality.

Linear
:   Linear light falloff, giving a slower decrease in intensity over distance.

Constant
:   Constant light falloff, where the distance to the light has no influence on its intensity.
user: How do I use Quick Start in Blender? Include parameters, examples, warnings and best practices.

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

### Create and Use Grease Pencil

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

### 2D Animation Template

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

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

- 2D Animation is the default active workspace.
- World Properties ‣ Surface (Background) ‣ Color is set to white.
- Color management [Views](../render/color_management/displays_views.xhtml#bpy-types-colormanagedviewsettings-view-transform) is set to *Standard*.
- The [drawing plane](modes/draw/drawing_planes.xhtml) is set to Front (X-Z).
- Line and Fill layers, along with some stroke materials, are configured for Grease Pencil.
- The animation timeline will automatically create a new keyframe when Grease Pencil is used on empty frames.
user: What is DynamicPaintCanvasSettings(bpy_struct) and how is it used in Blender Python scripting?

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
user: Give a detailed overview of StripCrop(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # StripCrop(bpy_struct)

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

*class* bpy.types.StripCrop(*bpy_struct*)
:   Cropping parameters for a sequence strip

    max_x
    :   Number of pixels to crop from the right side

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

    max_y
    :   Number of pixels to crop from the top

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

    min_x
    :   Number of pixels to crop from the left side

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

    min_y
    :   Number of pixels to crop from the bottom

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The relationships between linked data-blocks can change, resulting in outdated overrides.
When this happens, overrides need to be resynced to match the new structure of their hierarchy.
Overrides are automatically resynced if needed on blend-files opening. However,
it may be needed to resynced them manually sometimes, see [Troubleshoot an Override Hierarchy](#troubleshoot-an-override-hierarchy).
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: A
:   The first integer input. Used by all operations.

B
:   The second integer input. Only used by operations that require two inputs (*And*, *Or*, *Exclusive Or*).

Shift
:   The number of bits to shift or rotate. Used only for *Shift* and *Rotate* operations.
user: Describe Startup from the Blender manual or Python API, including usage steps and snippets.

assistant: # Startup

If Blender fails to start, there are a few common causes to check for:

- See if your computer meets the [minimum requirements](https://www.blender.org/download/requirements/).
- Confirm that your graphics card is supported and that the drivers are up to date (see
  [Troubleshooting Graphics Hardware](gpu/index.xhtml)).
- Make sure any antivirus software is not preventing Blender from starting.
- Ensure that you have appropriate user permissions on the computer.

If you cannot find a solution to your problem here, try asking the [community](../getting_started/about/community.xhtml)
for help.
user: Provide the full official documentation entry for GPU Options, preserving all code examples.

assistant: `--gpu-backend`
:   Force to use a specific GPU backend. Valid options: `vulkan`, `metal`, `opengl`.

`--gpu-vsync`
:   Set the VSync.
    Valid options are: `on`, `off` & `auto` for adaptive sync.

    - The default settings depend on the GPU driver.
    - Disabling VSync can be useful for testing performance.
    - `auto` is only supported by the OpenGL backend.

`--gpu-compilation-subprocesses`
:   Override the Max Compilation Subprocesses setting (OpenGL only).

`--profile-gpu`
:   Enable CPU & GPU performance profiling for GPU debug groups
    (Outputs a profile.json file in the Trace Event Format to the current directory)
user: How do I use BlendTexture(Texture) in Blender? Include parameters, examples, warnings and best practices.

assistant: # BlendTexture(Texture)

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

*class* bpy.types.BlendTexture(*Texture*)
:   Procedural color blending texture

    progression
    :   Style of the color blending

        - `LINEAR`
          Linear – Create a linear progression.
        - `QUADRATIC`
          Quadratic – Create a quadratic progression.
        - `EASING`
          Easing – Create a progression easing from one step to the next.
        - `DIAGONAL`
          Diagonal – Create a diagonal progression.
        - `SPHERICAL`
          Spherical – Create a spherical progression.
        - `QUADRATIC_SPHERE`
          Quadratic Sphere – Create a quadratic progression in the shape of a sphere.
        - `RADIAL`
          Radial – Create a radial progression.

        Type:
        :   enum in [`'LINEAR'`, `'QUADRATIC'`, `'EASING'`, `'DIAGONAL'`, `'SPHERICAL'`, `'QUADRATIC_SPHERE'`, `'RADIAL'`], default `'LINEAR'`

    use_flip_axis
    :   Flip the texture’s X and Y axis

        - `HORIZONTAL`
          Horizontal – No flipping.
        - `VERTICAL`
          Vertical – Flip the texture’s X and Y axis.

        Type:
        :   enum in [`'HORIZONTAL'`, `'VERTICAL'`], default `'HORIZONTAL'`

    users_material
    :   Materials that use this texture

        Type:
        :   tuple of [`Material`](bpy.types.Material.html#bpy.types.Material "bpy.types.Material")

        (readonly)

    users_object_modifier
    :   Object modifiers that use this texture

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Geometry
:   Standard geometry output.

Duplicate Index
:   An attribute field with a value for every output element describing which
    duplicate of the corresponding input. The value for every input element will
    start at 0 and increase to `Amount - 1`.
user: Show practical ways to work with Interface Tricks in a Blender add-on or script – include code.

assistant: ### Access Operator Commands

You may have noticed that the tooltip for menu items and buttons includes the `bpy.ops.[...]` command
to run that button, a handy (hidden) feature is that you can press `Ctrl`-`C` over
any menu item or button to copy this command into the clipboard.

### Access Data Path

To find the path from an `ID` data-block to its setting isn’t always so simple since it may be nested away.
To get this quickly open the context menu of the setting and select *Copy Data Path*,
if this can’t be generated, only the property name is copied.