PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Tool Settings and how is it used in Blender Python scripting?

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 side of the bounding box 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.

Subdivisions
:   Influences how many vertices are used to define the sphere.
    At level 1 the icosphere is an icosahedron, a solid with 20 equilateral triangular faces.
    Each increase in the number of subdivisions splits each triangular face into four.
user: Give a detailed overview of Tool Settings: syntax, arguments, return values, common patterns.

assistant: You can configure the brush main settings exposed on the Tool Settings for convenience.
For the draw brushes configuration and settings see:
[Draw Brush](../brushes/draw.xhtml).

Subdivisions
:   The number of stroke points between each stroke edge.

Thickness Profile
:   Use a [curve widget](../../../../interface/controls/templates/curve.xhtml) to define the stroke thickness
    from the start (left) to end (right) of the stroke.

    Use Curve
    :   When enabled, the stroke use a curve profile to control the thickness along the line.

Different thickness profile samples.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_polyline_thickness-profile-01.png | ../../../../_images/grease-pencil_modes_draw_tools_polyline_thickness-profile-02.png | ../../../../_images/grease-pencil_modes_draw_tools_polyline_thickness-profile-03.png |

### Brush Asset

Picks the brush asset used by the tool.

See [Brush Asset](../tool_settings/brushes.xhtml) for more information.

See [Draw Brushes](../brushes/draw.xhtml) for a detailed list of all draw brushes and their options.

### Brush Settings

Parameters to control to look of the stroke.

See [Draw Brushes](../brushes/draw.xhtml) for details.

### Color

Settings to determine the color of strokes.

See [Color](../tool_settings/color.xhtml)
user: Describe GeometryNodeTriangulate(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeTriangulate(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.GeometryNodeTriangulate(*GeometryNode*)
:   Convert all faces in a mesh to triangular faces

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

assistant: # NodeClosureInputItem(bpy_struct)

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

*class* bpy.types.NodeClosureInputItem(*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'`

    structure_type
    :   What kind of higher order types are expected to flow through this socket

        Type:
        :   enum in [Node Socket Structure Type Items](bpy_types_enum_items/node_socket_structure_type_items.html#rna-enum-node-socket-structure-type-items), default `'AUTO'`

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

assistant: # GeometryNodeAccumulateField(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.GeometryNodeAccumulateField(*GeometryNode*)
:   Add the values of an evaluated field together and output the running total for each element

    data_type
    :   Type of data that is accumulated

        - `FLOAT`
          Float – Add floating point values.
        - `INT`
          Integer – Add integer values.
        - `FLOAT_VECTOR`
          Vector – Add 3D vector values.
        - `TRANSFORM`
          Transform – Multiply transformation matrices.

        Type:
        :   enum in [`'FLOAT'`, `'INT'`, `'FLOAT_VECTOR'`, `'TRANSFORM'`], default `'FLOAT'`

    domain
    :   Type:
        :   enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items), default `'POINT'`

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

assistant: Type
:   Defines the type of light.

Temperature
:   Blackbody temperature in Kelvin, for natural light emission colors.

Color
:   Color tint of the emitted light.

Exposure
:   Multiply the light intensity by \(2^{exposure}\).
    This makes it easy to control a large range of intensities with a single slider.

Normalize
:   By default, the total power of the light remains the same when the light size and shape changes.
    By disabling this option, more light will be emitted when making the light bigger.
user: Provide the full official documentation entry for Active F-Curve, preserving all code examples.

assistant: [image reference removed]

Active F-Curve panel.

This panel displays properties for the active F-Curve.

Channel Name
:   The name of the property that’s animated by the curve.

Data Path
:   The programmatic path to the property.

RNA Array Index
:   The index into the property, for multi-value properties. As an example, the Location
    property has three values (X, Y and Z), which means it can have three different curves
    with indices 0, 1 and 2.

Display Color
:   How to determine the color of the F-Curve in the Graph editor.

    Auto Rainbow:
    :   Assigns a unique color to each curve that uses this setting.

    Auto XYZ to RGB:
    :   Detects curves that animate an X/Y/Z coordinate and colors them red/green/blue accordingly.

    User Defined:
    :   Lets you choose the color yourself.

Handle Smoothing
:   How to compute the [Bézier handles](#editors-graph-fcurves-settings-handles)
    when using the *Automatic* or *Auto Clamped* handle type.

    None:
    :   Only directly adjacent key values are considered when computing the handles.

        This older method is very simple and predictable, but it can only produce
        truly smooth curves in the most trivial cases. Notice that the red curve
        in the image above has a few kinks in the middle.

    Continuous Acceleration:
    :   A system of equations is solved in order to avoid or minimize jumps in acceleration
        at every keyframe.

        It produces much smoother curves out of the box, but necessarily means that
        any changes in the key values may affect interpolation over a significant stretch
        of the curve; although the amount of change decays exponentially with distance.
        This change propagation is stopped by any key with *Free*, *Aligned*, or *Vector*
        handles, as well as by extremes with *Auto Clamped* handles.

        The mode also tends to overshoot and oscillate more with fully *Automatic* handles
        in some cases (see the image above). So it is recommended to use *Auto Clamped* by default,
        and only switch to *Automatic* handles in places where this is desired behavior.
        That effect can also be reduced by adding in-between keys.

    [image reference removed]

    Handle smoothing mode comparison.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: As the modifier is only a container its actual options are configured in the *Physics Properties* tab.
See the [Dynamic Paint Physics Properties](../../../physics/dynamic_paint/index.html) for more information.
user: How do I use Inherited Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleAlphaModifier.name`](bpy.types.LineStyleAlphaModifier.html#bpy.types.LineStyleAlphaModifier.name "bpy.types.LineStyleAlphaModifier.name") |
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Points
:   Standard geometry input.

Density
:   Value of voxels inside the generated fog volume.

Resolution Mode
:   How the voxel size is specified.

    Amount:
    :   Specify the approximate number of voxels along the diagonal.

    Size:
    :   Specify the voxel side length. It is recommended to be careful when tweaking this value,
        because small changes can have a large effect on the processing time.

Voxel Amount Amount
:   Specify the approximate number of voxels along the diagonal.

Voxel Size Size
:   Specify the voxel side length.

Radius
:   Specify the radius of the sphere generated at each point.
user: How do I use CompositorNodeTransform(CompositorNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CompositorNodeTransform(CompositorNode)

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

*class* bpy.types.CompositorNodeTransform(*CompositorNode*)
:   Scale, translate and rotate an image

    *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")

    update()

    *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 Inherited Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`ViewerPathElem.type`](bpy.types.ViewerPathElem.html#bpy.types.ViewerPathElem.type "bpy.types.ViewerPathElem.type") | - [`ViewerPathElem.ui_name`](bpy.types.ViewerPathElem.html#bpy.types.ViewerPathElem.ui_name "bpy.types.ViewerPathElem.ui_name") |
user: Show practical ways to work with Supported Video & Audio Formats in a Blender add-on or script – include code.

assistant: # Supported Video & Audio Formats

Blender used [FFmpeg](https://ffmpeg.org/) to handle video encoding/decoding various video formats.
These formats are primarily used for compressing rendered sequences into a playable movie.
Video formats are composed of a container, a codec, and sometimes audio which is stored using its own codec.
The roll of the container to encapsulate video and audio data that is compressed using a codec.

Codecs compress the channels of a video down to save space and enable continuous playback.
*Lossy* codecs make smaller files at the expense of image quality,
while *lossless* codecs compress as much as possible the video/audio, but without losing any existing data.

Some codecs, like H.264, are great for larger images. Codecs are used to encode and decode the movie,
and so must be present on both the encoding machine (Blender) and the target machine.
The results of the encoding are stored in a container file.

There are dozens, if not hundreds, of codecs, including Xvid, H.264, DivX, Microsoft,
and so on. Each has advantages and disadvantages, and compatibility with different players on
different operating systems.
user: Give a detailed overview of With Automatic Weights: syntax, arguments, return values, common patterns.

assistant: *With Automatic Weights* parenting works similar to *With Empty Groups*,
but it will not leave the vertex groups empty. It calculates how much influence a particular bone
would have on vertices based on the distance from those vertices to a particular bone (“bone heat” algorithm).
This influence will be assigned as weights in the vertex groups.

This method of parenting is certainly easier to setup, but it can often lead to armatures which do not deform child
objects in ways you would want. Overlaps can occur when it comes to determining which bones should
influence certain vertices when calculating influences for more complex armatures and child objects.
Symptoms of this confusion are that when transforming the armature in *Pose Mode*,
parts of the child objects do not deform as you expect;
If Blender does not give you the results you require,
you will have to manually alter the weights of vertices in relation to the vertex groups they belong to and
have influence in.
user: What is Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

Copy Scale constraint.

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

Axis
:   The axes for which to copy scale factors.

Power
:   Raises the target’s scales to the specified power. This is done before applying
    the *Offset*.

Make Uniform
:   Instead of applying the scale for each individual axis, apply a uniform scale
    to all axes that achieves the same overall change in volume.

Offset
:   When enabled, the target’s current scale (from all its constraints) is not
    copied over, but multiplied with the owner’s original scale
    (from its preceding constraints).

Additive
:   When *Offset* is enabled, don’t use multiplication, but add the owner’s scales minus 1.
    This option is kept for backwards compatibility, but generally makes no sense and should not be used.

[Target/Owner](../interface/common.xhtml#rigging-constraints-interface-common-space)
:   The spaces for retrieving the scales from the target and for applying them to the owner.

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

assistant: # BoidRuleAvoidCollision(BoidRule)

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

*class* bpy.types.BoidRuleAvoidCollision(*BoidRule*)
:   look_ahead
    :   Time to look ahead in seconds

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

    use_avoid
    :   Avoid collision with other boids

        Type:
        :   boolean, default False

    use_avoid_collision
    :   Avoid collision with deflector objects

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

assistant: # Eyedropper

The eyedropper (pipette icon) allows you to sample from anywhere in the Blender window.
The eyedropper can be used to select different kinds of data:

Color
:   This is the most common usage. The eyedropper is used to sample a pixel’s color from anywhere within Blender.

Color Ramp
:   Dragging the cursor over the window to sample a line which is converted into a color ramp.

Objects/Object-Data
:   This is used with object buttons (such as parent, constraints or modifiers) to
    select an object from the 3D Viewport or Outliner, rather than having to select it from a drop-down.

Bones
:   This is used when a subtarget to an armature can be chosen. It is possible to
    choose a bone from the 3D Viewport or from the outliner. Only bones that belong
    to the armature that was chosen as a target can be picked.

Camera Depth
:   Number fields effecting distance can also use the eyedropper.

    This is used to set the camera’s depth of field so the depth chosen is in focus.

- `E` will activate the eyedropper while hovering over a button.
- `LMB` dragging will mix the colors you drag over, which can help when sampling noisy imagery.
- `Spacebar` resets and starts mixing the colors again.
user: How do I use Quick Effects in Blender? Include parameters, examples, warnings and best practices.

assistant: Sets up a basic simulation scene or effect including the selected objects.
The tool will add essential objects like domains or particle systems both with predefined settings,
so that there will be instant viewable result.

### Quick Fur

Adds a fur setup to the selected objects.
The fur setup is based on [Geometry Nodes](../modeling/geometry_nodes/index.xhtml) and built with
[Hair Node Groups](../modeling/geometry_nodes/hair/index.xhtml) that come with Blender as bundled assets.

Density
:   Surface density of generated hair curves.

Length
:   Length of the generated hair curves.

Hair Radius
:   The width of the hair, used for rendering engines.

View Percentage
:   Factor applied on the density for the viewport.

Apply Hair Curves
:   Applies the modifier that uses the [Generate Hair Curves](../modeling/geometry_nodes/hair/generation/generate_hair_curves.xhtml) node group.

Noise
:   Deforms hair curves using a noise texture.
    See the [Hair Curves Noise](../modeling/geometry_nodes/hair/deformation/hair_curves_noise.xhtml) node group for more information.

Frizz
:   Deforms hair curves using a random vector per point to frizz them.
    See the [Frizz Hair Curves](../modeling/geometry_nodes/hair/deformation/frizz_hair_curves.xhtml) node group for more information.
user: Describe Extrude Vertices from the Blender manual or Python API, including usage steps and snippets.

assistant: # Extrude Vertices

Extrude vertices as individual vertices.

|  |  |
| --- | --- |
| <../../../../_images/modeling_meshes_editing_vertex_extrude-vertices_before.png>   Vertex selected. | <../../../../_images/modeling_meshes_editing_vertex_extrude-vertices_after.png>   Vertices extrude. |
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`Armature.collections`](bpy.types.Armature.html#bpy.types.Armature.collections "bpy.types.Armature.collections") - [`Armature.collections_all`](bpy.types.Armature.html#bpy.types.Armature.collections_all "bpy.types.Armature.collections_all") - [`Bone.collections`](bpy.types.Bone.html#bpy.types.Bone.collections "bpy.types.Bone.collections") - [`BoneCollection.children`](#bpy.types.BoneCollection.children "bpy.types.BoneCollection.children") - [`BoneCollection.parent`](#bpy.types.BoneCollection.parent "bpy.types.BoneCollection.parent") | - [`BoneCollections.active`](bpy.types.BoneCollections.html#bpy.types.BoneCollections.active "bpy.types.BoneCollections.active") - [`BoneCollections.new`](bpy.types.BoneCollections.html#bpy.types.BoneCollections.new "bpy.types.BoneCollections.new") - [`BoneCollections.new`](bpy.types.BoneCollections.html#bpy.types.BoneCollections.new "bpy.types.BoneCollections.new") - [`BoneCollections.remove`](bpy.types.BoneCollections.html#bpy.types.BoneCollections.remove "bpy.types.BoneCollections.remove") - [`EditBone.collections`](bpy.types.EditBone.html#bpy.types.EditBone.collections "bpy.types.EditBone.collections") |
user: Give a detailed overview of GpWeightPaint(Paint): syntax, arguments, return values, common patterns.

assistant: # GpWeightPaint(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.GpWeightPaint(*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 Unsupported Graphics Driver Error in a Blender add-on or script – include code.

assistant: This means your graphics card and driver do not have the minimum required OpenGL 3.3 version needed by Blender.

Installing the latest version of the correct driver can help upgrade the OpenGL version, though some graphics cards
are simply too old to run the latest Blender. In such cases, using Blender 2.79 or earlier is the only option.
Starting with Blender 2.8 (which added EEVEE), there is less support for older graphics hardware.
user: How do I use Transform Pivot Point in Blender? Include parameters, examples, warnings and best practices.

assistant: # Transform Pivot Point

The *Pivot Point* determines the location of the
[Object Gizmo](../../display/gizmo.xhtml).
Changing this location can make it easier to perform
transformations around the point you want.

[image reference removed]

With the default “Median Point” pivot point (left) it’s tricky to
bring the second wheel spoke into place, but with “3D Cursor” (right)
it’s easy.

The Pivot Point can be changed using a selector in the 3D Viewport’s header:

[image reference removed]
user: Give a detailed overview of T: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [Tags](advanced/extensions/tags.html#index-0) - [**Tail**](glossary/index.html#term-Tail) - [**Tangent**](glossary/index.html#term-Tangent) - [**Tessellation**](glossary/index.html#term-Tessellation) - [**Texture**](glossary/index.html#term-Texture) - [**Texture Space**](glossary/index.html#term-Texture-Space) - [**Timecode**](glossary/index.html#term-Timecode) | - [**Title Safe**](glossary/index.html#term-Title-Safe) - [**Topology**](glossary/index.html#term-Topology) - [**Transform**](glossary/index.html#term-Transform)   - [Modeling Transform](modeling/transform/introduction.html#index-0) - [**Transformation**](glossary/index.html#term-Transformation) - [**Transformation Matrix**](glossary/index.html#term-Transformation-Matrix) - [**Triangle**](glossary/index.html#term-Triangle) |
user: What is GeometryNodeInputMeshFaceIsPlanar(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeInputMeshFaceIsPlanar(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.GeometryNodeInputMeshFaceIsPlanar(*GeometryNode*)
:   Retrieve whether all triangles in a face are on the same plane, i.e. whether they have the same normal

    *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

    *classmethod* input_template(*index*)
    :   Input socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

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

    *classmethod* output_template(*index*)
    :   Output socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Laplacian Smooth

See the [Laplacian Smooth Modifier](../../../modifiers/deform/laplacian_smooth.html) for details.

Laplacian smooth uses an alternative smoothing algorithm that better preserves larger details and
this way the overall shape of the mesh. Laplacian smooth exists as a mesh operation and
as a non-destructive modifier.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Curve
:   Standard geometry input.

Selection
:   Whether or not to change the direction of each spline. True values mean the direction will be changed,
    false values mean the spline will be unaffected.
user: Explain Bpy.Types.Nodetreeinterfacesocketvectorvelocity in complete detail according to the official Blender documentation.

assistant: unctions
user: Explain Subdivision Uv Smooth Items in complete detail according to the official Blender documentation.

assistant: # Subdivision Uv Smooth Items

NONE:
:   None.

    UVs are not smoothed, boundaries are kept sharp.

PRESERVE_CORNERS:
:   Keep Corners.

    UVs are smoothed, corners on discontinuous boundary are kept sharp.

PRESERVE_CORNERS_AND_JUNCTIONS:
:   Keep Corners, Junctions.

    UVs are smoothed, corners on discontinuous boundary and junctions of 3 or more regions are kept sharp.

PRESERVE_CORNERS_JUNCTIONS_AND_CONCAVE:
:   Keep Corners, Junctions, Concave.

    UVs are smoothed, corners on discontinuous boundary, junctions of 3 or more regions and darts and concave corners are kept sharp.

PRESERVE_BOUNDARIES:
:   Keep Boundaries.

    UVs are smoothed, boundaries are kept sharp.

SMOOTH_ALL:
:   All.

    UVs and boundaries are smoothed.
user: Explain Align Rotation in complete detail according to the official Blender documentation.

assistant: The *Align Rotation* tool aligns entire islands to either the U or V axis.

The tool has three different methods of operation.
The different methods specify the source for the alignment,
and also whether to align with both the U and V axes,
or just the V axis alone.

When using the *Auto* method, islands are aligned so that UV edges are aligned
to either the U axis or the V axis. This method works best with quads
and meshes representing organic subjects.

When using the *Edge* method, only the selected edges are considered,
and the islands will be aligned such that the selected edges are aligned
with the V axis. This method works with the selection, so it works best
when a particular edge, or edge loop, needs to be aligned in UV coordinates.

When using the *Geometry* method, the geometry is taken into consideration.
Either the *X* axis, the *Y* axis, or the *Z* axis can be used. Suppose
the *X* axis is chosen. Using this method, edges which have a positive extent
in the *X* axis will be rotated in the UV map so that the edge
extends upwards in the *V* axis.
This method works best to align multiple islands which share some common
geometric property, either in the X, Y or Z axis.

Note that in the *Auto* method, edges can end up aligned either up or down or left or right
depending on the orientation of the island prior to activating the tool.
In the *Edge* method, the alignment of selected edges can be either up
or down in the V axis, whatever is closest to the current orientation of the UV island.
By comparison, in the *Geometry* method, the alignment will always be pointing up in the V axis,
ignoring any previous orientation.
user: Describe Normalize All from the Blender manual or Python API, including usage steps and snippets.

assistant: For each vertex, this tool makes sure that the sum of the weights across
all vertex groups is equal to 1. This tool normalizes all of the vertex groups,
except for locked groups, which keep their weight values untouched.

Lock Active
:   Keep the values of the active group while normalizing all the others.
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: ### bpy.context

This module gives you access to the current scene,
the currently selected objects, the current object mode, and so on.

[image reference removed]

Get the current 3D Viewport mode (Object, Edit, Sculpt, etc.):

```
bpy.context.mode
```

Get the active object:

```
bpy.context.object
bpy.context.active_object
```

Change the active object’s X coordinate to 1:

```
bpy.context.object.location.x = 1
```

Move the active object by 0.5 along the X axis:

```
bpy.context.object.location.x += 0.5
```

Change all three location coordinates in one go:

```
bpy.context.object.location = (1, 2, 3)
```

Change only the X and Y coordinates:

```
bpy.context.object.location.xy = (1, 2)
```

Get the selected objects:

```
bpy.context.selected_objects
```

Get the selected objects excluding the active one:

```
[obj for obj in bpy.context.selected_objects if obj != bpy.context.object]
```

### bpy.data

Gives you access to all the data in the blend-file,
regardless of whether it’s currently active or selected.

[image reference removed]

### bpy.ops

“Operators” are actions that are normally triggered from a button or menu item
but can also be called programmatically. See the
[bpy.ops](https://docs.blender.org/api/current/bpy.ops.html)
API documentation for a list of all operators.
user: Explain Propagate in complete detail according to the official Blender documentation.

assistant: # Propagate

The Propagate tool copies the pose of the selected bones on the current frame over
to the keyframes delimited by the *Termination Mode*.
It automates the process of copying and pasting.

Termination Mode
:   Modes which determine how it decides when to stop overwriting keyframes.

    To Next Keyframe
    :   Simply copies the pose to the first keyframe after (but not including any keyframe on) the current frame.

    To Last Keyframe
    :   Will simply replace the last keyframe (i.e. making action cyclic).

    Before Frame
    :   To all keyframes between current frame and the *End frame* option.
        This option is best suited for use from scripts due to the difficulties in setting this frame value,
        though it is possible to set this manually
        via the [Adjust Last Operation](../../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel if necessary.

    Before Last Keyframe
    :   To all keyframes from current frame until no more are found.

    On Selected Keyframes
    :   Will apply the pose of the selected bones to all selected keyframes.

    On Selected Markers
    :   To all keyframes occurring on frames with Scene Markers after the current frame.

End Frame
:   Defines the upper-bound for the frame range within which keyframes
    will be affected (with the lower bound being the current frame).
user: How do I use Local Cache Directory in Blender? Include parameters, examples, warnings and best practices.

assistant: The cache directory is used to store persistent caches locally. Currently it is only used for the indexing of
[Asset Libraries](../files/asset_libraries/introduction.xhtml#what-is-asset-library). The operating system is not expected to clear this automatically.

The following path will be used:

- Linux:
  :   `$XDG_CACHE_HOME/blender/` if `$XDG_CACHE_HOME` is set, otherwise `$HOME/.cache/blender/`
- macOS:
  :   `/Library/Caches/Blender/`
- Windows:
  :   `%USERPROFILE%\AppData\Local\Blender Foundation\Blender\Cache\`
user: How do I use Module Functions in Blender? Include parameters, examples, warnings and best practices.

assistant: bmesh.from_edit_mesh(*mesh*)
:   Return a BMesh from this mesh, currently the mesh must already be in editmode.

    Parameters:
    :   **mesh** ([`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh")) – The editmode mesh.

    Returns:
    :   the BMesh associated with this mesh.

    Return type:
    :   `bmesh.types.BMesh`

bmesh.new(*\**, *use_operators=True*)
:   Parameters:
    :   **use_operators** (*bool*) – Support calling operators in [`bmesh.ops`](bmesh.ops.html#module-bmesh.ops "bmesh.ops") (uses some extra memory per vert/edge/face).

    Returns:
    :   Return a new, empty BMesh.

    Return type:
    :   `bmesh.types.BMesh`

bmesh.update_edit_mesh(*mesh*, *\**, *loop_triangles=True*, *destructive=True*)
:   Update the mesh after changes to the BMesh in editmode,
    optionally recalculating n-gon tessellation.

    Parameters:
    :   - **mesh** ([`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh")) – The editmode mesh.
        - **loop_triangles** (*bool*) – Option to recalculate n-gon tessellation.
        - **destructive** (*bool*) – Use when geometry has been added or removed.
user: Give a detailed overview of Fill Brushes: syntax, arguments, return values, common patterns.

assistant: Fill brushes are the special type of brushes that uses Grease Pencil for the *Fill* tools.
The brush can be changed in the Tool Settings.
The different fill brushes are settings variations of the same *Fill Brush*.
You can create many brushes, each with unique settings to get different result when filling areas.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Domain
:   Which [attribute domain](../attributes_reference.xhtml#attribute-domains) to store the evaluated data on.

### Capture Items

[List View](../../../interface/controls/templates/list_view.xhtml#ui-list-view) for adding, removing, reordering, and renaming the inputs of the node.

Data Type
:   The [data type](../attributes_reference.xhtml#attribute-data-types) of the selected input.
user: What is Inherited Properties and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`GreasePencilTreeNode.name`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.name "bpy.types.GreasePencilTreeNode.name") - [`GreasePencilTreeNode.hide`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.hide "bpy.types.GreasePencilTreeNode.hide") - [`GreasePencilTreeNode.lock`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.lock "bpy.types.GreasePencilTreeNode.lock") - [`GreasePencilTreeNode.select`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.select "bpy.types.GreasePencilTreeNode.select") - [`GreasePencilTreeNode.use_onion_skinning`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.use_onion_skinning "bpy.types.GreasePencilTreeNode.use_onion_skinning") | - [`GreasePencilTreeNode.use_masks`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.use_masks "bpy.types.GreasePencilTreeNode.use_masks") - [`GreasePencilTreeNode.channel_color`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.channel_color "bpy.types.GreasePencilTreeNode.channel_color") - [`GreasePencilTreeNode.next_node`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.next_node "bpy.types.GreasePencilTreeNode.next_node") - [`GreasePencilTreeNode.prev_node`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.prev_node "bpy.types.GreasePencilTreeNode.prev_node") - [`GreasePencilTreeNode.parent_group`](bpy.types.GreasePencilTreeNode.html#bpy.types.GreasePencilTreeNode.parent_group "bpy.types.GreasePencilTreeNode.parent_group") |
user: Describe WhiteBalanceModifier(StripModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # WhiteBalanceModifier(StripModifier)

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

*class* bpy.types.WhiteBalanceModifier(*StripModifier*)
:   White balance modifier for sequence strip

    open_mask_input_panel
    :   Type:
        :   boolean, default False

    white_value
    :   This color defines white in the strip

        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 References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeBake.active_item`](bpy.types.GeometryNodeBake.html#bpy.types.GeometryNodeBake.active_item "bpy.types.GeometryNodeBake.active_item") - [`GeometryNodeCaptureAttribute.active_item`](bpy.types.GeometryNodeCaptureAttribute.html#bpy.types.GeometryNodeCaptureAttribute.active_item "bpy.types.GeometryNodeCaptureAttribute.active_item") - [`GeometryNodeFieldToGrid.active_item`](bpy.types.GeometryNodeFieldToGrid.html#bpy.types.GeometryNodeFieldToGrid.active_item "bpy.types.GeometryNodeFieldToGrid.active_item") - [`GeometryNodeRepeatOutput.active_item`](bpy.types.GeometryNodeRepeatOutput.html#bpy.types.GeometryNodeRepeatOutput.active_item "bpy.types.GeometryNodeRepeatOutput.active_item") | - [`GeometryNodeRepeatOutput.repeat_items`](bpy.types.GeometryNodeRepeatOutput.html#bpy.types.GeometryNodeRepeatOutput.repeat_items "bpy.types.GeometryNodeRepeatOutput.repeat_items") - [`NodeGeometryRepeatOutputItems.new`](bpy.types.NodeGeometryRepeatOutputItems.html#bpy.types.NodeGeometryRepeatOutputItems.new "bpy.types.NodeGeometryRepeatOutputItems.new") - [`NodeGeometryRepeatOutputItems.remove`](bpy.types.NodeGeometryRepeatOutputItems.html#bpy.types.NodeGeometryRepeatOutputItems.remove "bpy.types.NodeGeometryRepeatOutputItems.remove") |
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: R
:   The radial distance from the origin.

Phi
:   The azimuthal angle (horizontal rotation) around the Z axis, measured in radians.

Theta
:   The polar angle (vertical inclination) from the Z axis, measured in radians.
user: Give a detailed overview of Group Output: syntax, arguments, return values, common patterns.

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

assistant: Gizmo settings for [cameras](../../../render/cameras.xhtml).

Lens
:   Show the gizmo to adjust the focal length (for Perspective cameras)
    or orthographic scale (for Orthographic cameras).

Focus Distance
:   Enable the gizmo for adjusting the focus distance. To see this gizmo,
    you need to enable the Viewport Display ‣ Limits checkbox
    in the camera’s properties (green camera icon).