PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe bpy_extras submodule (bpy_extras.mesh_utils) from the Blender manual or Python API, including usage steps and snippets.

assistant: # bpy_extras submodule (bpy_extras.mesh_utils)

bpy_extras.mesh_utils.mesh_linked_uv_islands(*mesh*)
:   Returns lists of polygon indices connected by UV islands.

    Parameters:
    :   **mesh** ([`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh")) – the mesh used to group with.

    Returns:
    :   list of lists containing polygon indices

    Return type:
    :   list[list[int]]

bpy_extras.mesh_utils.mesh_linked_triangles(*mesh*)
:   Splits the mesh into connected triangles, use this for separating cubes from
    other mesh elements within 1 mesh data-block.

    Parameters:
    :   **mesh** ([`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh")) – the mesh used to group with.

    Returns:
    :   Lists of lists containing triangles.

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

bpy_extras.mesh_utils.edge_face_count_dict(*mesh*)
:   Returns:
    :   Dictionary of edge keys with their value set to the number of faces using each edge.

    Return type:
    :   dict[tuple[int, int], int]

bpy_extras.mesh_utils.edge_face_count(*mesh*)
:   Returns:
    :   list face users for each item in mesh.edges.

    Return type:
    :   list[int]

bpy_extras.mesh_utils.edge_loops_from_edges(*mesh*, *edges=None*)
:   Edge loops defined by edges

    Takes me.edges or a list of edges and returns the edge loops

    return a list of vertex indices.
    [ [1, 6, 7, 2], …]

    closed loops have matching start and end values.

bpy_extras.mesh_utils.ngon_tessellate(*from_data*, *indices*, *fix_loops=True*, *debug_print=True*)
:   Takes a poly-line of indices (ngon) and returns a list of face
    index lists. Designed to be used for importers that need indices for an
    ngon to create from existing verts.

    Parameters:
    :   - **from_data** ([`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh") | list[Sequence[float]] | tuple[Sequence[float]]) – Either a mesh, or a list/tuple of 3D vectors.
        - **indices** (*list**[**int**]*) – a list of indices to use this list
          is the ordered closed poly-line
          to fill, and can be a subset of the data given.
        - **fix_loops** (*bool*) – If this is enabled poly-lines
          that use loops to make multiple
          poly-lines are dealt with correctly.

bpy_extras.mesh_utils.triangle_random_points(*num_points*, *loop_triangles*)
:   Generates a list of random points over mesh loop triangles.

    Parameters:
    :   - **num_points** (*int*) – The number of random points to generate on each triangle.
        - **loop_triangles** (Sequence[[`bpy.types.MeshLoopTriangle`](bpy.types.MeshLoopTriangle.html#bpy.types.MeshLoopTriangle "bpy.types.MeshLoopTriangle")]) – Sequence of the triangles to generate points on.

    Returns:
    :   List of random points over all triangles.

    Return type:
    :   list[[`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector")]
user: Provide the full official documentation entry for MultiplyStrip(EffectStrip), preserving all code examples.

assistant: # MultiplyStrip(EffectStrip)

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

*class* bpy.types.MultiplyStrip(*EffectStrip*)
:   Multiply Strip

    input_1
    :   First input for the effect strip

        Type:
        :   [`Strip`](bpy.types.Strip.html#bpy.types.Strip "bpy.types.Strip"), (never None)

    input_2
    :   Second input for the effect strip

        Type:
        :   [`Strip`](bpy.types.Strip.html#bpy.types.Strip "bpy.types.Strip"), (never None)

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

assistant: ### Selecting a Brush and Material

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

### Creating Arcs

1. Click (`LMB` or the `Pen` tip) and drag the start point.
2. Release on the desired end point.
3. After releasing you can tweak the arc using a single cyan manipulator (hand icon).
4. Then confirm (`Return`/`MMB`) or cancel (`Esc`/`RMB`).

While dragging you can use `Shift` to make a perfect arc,
use `Alt` to create the arc from a center point or `M` to flip.

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

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

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_arc_example-01.png   click and dragging the start point. | ../../../../_images/grease-pencil_modes_draw_tools_arc_example-02.png   Tweaking arc with the manipulator. | ../../../../_images/grease-pencil_modes_draw_tools_arc_example-03.png   The arc after confirming. |

### Extruding

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

|  |  |  |
| --- | --- | --- |
| ../../../../_images/grease-pencil_modes_draw_tools_arc_extrude-01.png   End point extruding. | ../../../../_images/grease-pencil_modes_draw_tools_arc_extrude-02.png   Tweaking the last arc with the manipulator. | ../../../../_images/grease-pencil_modes_draw_tools_arc_extrude-03.png   The connected arcs after confirming. |
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

Object Solver constraint.

Active Clip
:   Whether the physical object is in the scene’s [Active Clip](../../../scene_layout/scene/properties.html#bpy-types-scene-active-clip).
    If unchecked, a selector appears for choosing another clip.

Object
:   The physical object whose motion to imitate. See the [Objects Panel](../../../movie_clip/tracking/clip/sidebar/track/objects.html)
    in the Movie Clip Editor’s Sidebar for setting this up.

Camera
:   The Blender camera matching the physical camera that recorded the object.
    If left empty, the scene’s [active camera](../../../scene_layout/scene/properties.html#bpy-types-scene-camera) is used.

    If the physical camera was in motion, the Blender camera should have a
    [Camera Solver Constraint](camera_solver.html). This constraint is useful even if
    the physical camera was stationary, because it makes the tracking markers appear at their
    reconstructed world positions in the 3D Viewport (if the [Motion Tracking](../../../editors/3dview/display/overlays.html#bpy-types-spaceview3d-show-reconstruction)
    overlay is enabled).

Set Inverse
:   Tell the constraint that the current Location of the Blender object (that is, its position with the constraint
    *disabled*) is the correct position for the current frame. Once this information is saved, the object will
    also be in the correct position for the other frames.

    - When initially adding the constraint:

      - Bring the object into position for the current frame.
      - Add the constraint.
      - Click *Set Inverse*.
    - When tweaking the object’s position at a later point:

      - Run [Apply Visual Transform](../../../scene_layout/object/editing/apply.html#bpy-ops-object-visual-transform-apply). (This may move the object
        to a different position.)
      - Disable the constraint. (This will bring the object back to its previous position.)
      - Tweak the object’s position as desired.
      - Click *Set Inverse*.
      - Enable the constraint.

Clear Inverse
:   Resets the relative transformation that was stored by *Set Inverse*.

Constraint to F-Curve
:   Replaces the constraint by a set of equivalent keyframes.

[Influence](../interface/common.html#bpy-types-constraint-influence)
:   How strongly the constraint affects its owner.
user: Describe Split Toning Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Split Toning Node

[image reference removed]

The *Split Toning* node applies different color tints to the highlights and shadows of an image.
This technique is widely used in photography and color grading to create mood, enhance contrast,
or stylize an image by giving distinct color tones to bright and dark regions.

For example, warm highlights and cool shadows can evoke a cinematic or nostalgic look,
while complementary tones can create stylized or dramatic effects.
user: What is NodeSocketVectorDirection4D(NodeSocketStandard) and how is it used in Blender Python scripting?

assistant: # NodeSocketVectorDirection4D(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorDirection4D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    links
    :   List of node links from or to this socket.

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of bpy_extras submodule (bpy_extras.keyconfig_utils): syntax, arguments, return values, common patterns.

assistant: # bpy_extras submodule (bpy_extras.keyconfig_utils)

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

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

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

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

assistant: # ParticleSystems(bpy_struct)

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

*class* bpy.types.ParticleSystems(*bpy_struct*)
:   Collection of particle systems

    active
    :   Active particle system being displayed

        Type:
        :   [`ParticleSystem`](bpy.types.ParticleSystem.html#bpy.types.ParticleSystem "bpy.types.ParticleSystem"), (readonly)

    active_index
    :   Index of active particle system slot

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is GeometryNodeInputTangent(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeInputTangent(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.GeometryNodeInputTangent(*GeometryNode*)
:   Retrieve the direction of curves at each control 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: What is Creating Meta-rigs and how is it used in Blender Python scripting?

assistant: # Creating Meta-rigs

1. Add a single bone from the Add ‣ Armature menu.
2. Go in armature Edit Mode and build the meta rig by samples or Rigify types.
3. Define the [Rigify bone collection UI](#bpy-types-bonecollection-rigify-ui-row),
   [color sets](#bpy-types-armature-rigify-colors), and selection sets.
4. In the armature properties click on the *Generate* button to generate the rig.
user: Show practical ways to work with Extensions Command Line Arguments in a Blender add-on or script – include code.

assistant: # Extensions Command Line Arguments

Command for managing Blender extensions.

options:
:   `-h, --help`
    :   show this help message and exit

subcommands:

> [Package Management](#package-management)
> :   list:
>     :   List all packages.
>
>     sync:
>     :   Synchronize with remote repositories.
>
>     update:
>     :   Upgrade any outdated packages.
>
>     install:
>     :   Install packages.
>
>     install-file:
>     :   Install package from file.
>
>     remove:
>     :   Remove packages.
>
> [Repository Management](#repository-management)
> :   repo-list:
>     :   List repositories.
>
>     repo-add:
>     :   Add repository.
>
>     repo-remove:
>     :   Remove repository.
>
> [Extension Creation](#extension-creation)
> :   build:
>     :   Build a package.
>
>     validate:
>     :   Validate a package.
>
>     server-generate:
>     :   Create a listing from all packages.
user: Explain Rigidbody Object Shape Items in complete detail according to the official Blender documentation.

assistant: # Rigidbody Object Shape Items

BOX:
:   Box.

    Box-like shapes (i.e. cubes), including planes (i.e. ground planes).

SPHERE:
:   Sphere.

CAPSULE:
:   Capsule.

CYLINDER:
:   Cylinder.

CONE:
:   Cone.

CONVEX_HULL:
:   Convex Hull.

    A mesh-like surface encompassing (i.e. shrinkwrap over) all vertices (best results with fewer vertices).

MESH:
:   Mesh.

    Mesh consisting of triangles only, allowing for more detailed interactions than convex hulls.

COMPOUND:
:   Compound Parent.

    Combines all of its direct rigid body children into one rigid object.
user: Provide the full official documentation entry for Curve Tip, preserving all code examples.

assistant: # Curve Tip

The *Curve Tip* node outputs information about the tip (end) point of each curve.
It is commonly used in hair grooming, deformation, and simulation setups to control
operations at the ends of curves, such as shaping, alignment, or applying tip-based effects.
user: How do I use NodeSocketFloatFactor(NodeSocketStandard) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeSocketFloatFactor(NodeSocketStandard)

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

*class* bpy.types.NodeSocketFloatFactor(*NodeSocketStandard*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    links
    :   List of node links from or to this socket.

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use GeometryNodeCurvePrimitiveLine(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeCurvePrimitiveLine(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.GeometryNodeCurvePrimitiveLine(*GeometryNode*)
:   Generate a poly spline line with two points

    mode
    :   Method used to determine radius and placement

        - `POINTS`
          Points – Define the start and end points of the line.
        - `DIRECTION`
          Direction – Define a line with a start point, direction and length.

        Type:
        :   enum in [`'POINTS'`, `'DIRECTION'`], default `'POINTS'`

    *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 Release Checklist in complete detail according to the official Blender documentation.

assistant: - Create a release branch (`blender-3.2-release/`)
- Update the splash image: `interface_splash_current.png` in the release branch.
- Increase the `conf.py: blender_version` variable in the trunk version.
user: How do I use Minimize Stretch in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Minimize Stretch* tool, reduces UV stretch by minimizing the difference between
the angles in 3D and the angles in UV space.
This operation is similar to the [Relax](tools/relax.xhtml)
tool with the *Geometry* *Method*, but uses a different algorithm.

Fill Holes
:   Just during *minimize stretch*, internal holes will be filled with temporary polygons
    to prevent stretching and overlaps of the surrounding UVs.

Blend
:   The fraction between 0 and 1 of the original UVs to blend in once the stretch is minimized.
    A blend of 0 is the fully minimized stretch. Blend of 0.5 is halfway between the original UVs
    and the minimize stretch UVs.

Iterations
:   More iterations result in smoother UVs, but take longer to process.
user: Describe Expand from the Blender manual or Python API, including usage steps and snippets.

assistant: # Expand

This is a multi-purpose modal operator to intuitively create and edit masks/face sets.
When executed, it uniformly expand outwards a pattern from the vertex under the cursor.

There is also a [full showcase of the Expand features and use cases](https://www.youtube.com/watch?v=XT7h6lmE5bc).

[image reference removed]

A preview of *Expand Mask by Topology*
user: How do I use General Tools in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

General transform and annotate tools like in other modes.

[Move](tools/transforms.xhtml)
:   Translation tool.

[Rotate](tools/transforms.xhtml)
:   Rotation tool.

[Scale](tools/transforms.xhtml)
:   Scale tool.

[Transform](tools/transforms.xhtml)
:   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.
user: How do I use Reference API Scope in Blender? Include parameters, examples, warnings and best practices.

assistant: The reference API covers [`bpy.types`](bpy.types.html#module-bpy.types "bpy.types"), which stores types accessed via [`bpy.context`](bpy.context.html#module-bpy.context "bpy.context") – *the user context*
or [`bpy.data`](bpy.data.html#module-bpy.data "bpy.data") – *blend-file data*.

Other modules such as [`bmesh`](bmesh.html#module-bmesh "bmesh") and [`aud`](aud.html#module-aud "aud") are not using Blender’s data API
so this document doesn’t apply to those modules.
user: Show practical ways to work with Multiresolution Modifier in a Blender add-on or script – include code.

assistant: # Multiresolution Modifier

The *Multiresolution* modifier (often shortened to “Multires”)
gives you the ability to subdivide a mesh similarly
to the [Subdivision Surface](subdivision_surface.xhtml) modifier,
but also allows you to edit the new subdivision levels in
[Sculpt Mode](../../../sculpt_paint/sculpting/introduction/adaptive.xhtml).

Deform modifiers will be applied onto the Multires subdivision levels instead of the base mesh,
if they come after the Multires.
user: How do I use GeometryNodeSetCurveTilt(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeSetCurveTilt(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.GeometryNodeSetCurveTilt(*GeometryNode*)
:   Set the tilt angle at each curve control 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: Show practical ways to work with face.skin_jaw in a Blender add-on or script – include code.

assistant: Implements a skin system [parent controller](skin.xhtml#rigify-rigs-skin-skin-parents) that manages
one or more loops of mouth skin chains in response to the movement of jaw and mouth controls.

The rig must have one or more child chain loops, each formed by four skin chains tagged
with `.T`/`.B` and `.L`/`.R` symmetrical names.

The lip loops are sorted into layers based on the distance from corners to the common
center and rigged with blended influence of the jaw and the master mouth control.
Other child rigs become children of the jaw.

Bottom Lip Influence
:   Specifies the influence of the jaw on the inner bottom lip with mouth lock disabled.

Locked Influence
:   Specifies the influence of the jaw on both lips of locked mouth.

Secondary Influence Falloff
:   Specifies the factor by which influence fades away with each successive lip loop
    (for bottom lip loops the blend moves away from inner bottom lip to full jaw influence).
user: Explain Main Region in complete detail according to the official Blender documentation.

assistant: At least one region is always visible.
It is called the Main region and is the most prominent part of the editor.

Each editor has a specific purpose, so the main region and
the availability of additional regions are different between editors.
See specific documentation about each editor in the [Editors](../../editors/index.xhtml) chapter.
user: What is NodeSocketFloatColorTemperature(NodeSocketStandard) and how is it used in Blender Python scripting?

assistant: # NodeSocketFloatColorTemperature(NodeSocketStandard)

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

*class* bpy.types.NodeSocketFloatColorTemperature(*NodeSocketStandard*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    links
    :   List of node links from or to this socket.

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Blur Attribute Node in complete detail according to the official Blender documentation.

assistant: # Blur Attribute Node

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

The *Blur Attribute* node smooths attribute values between neighboring geometry elements.

The goal of each step is mixing values of each element with its neighbors.
The weight for element is factor for multiplying all neighbor’s values before accumulating them as new primitive
value.

Blurring will only work with certain geometry types and [attribute domains](../attributes_reference.html#attribute-domains).
Therefore, the attribute can only be affected on the [Meshes](../../meshes/introduction.html) and
[Curves](../../curves/introduction.html) components.

The domains this node works on is based on the [field context](../fields.html#field-context) of the node’s evaluation.
Only domains with explicit relations with their neighbors will work with this node.
Explicit relations for correct blurring are vertices, edges, and faces of meshes, and curve control points.

All [attribute data types](../attributes_reference.html#attribute-data-types) are supported except
for boolean attributes.
user: Give a detailed overview of Brush Settings: syntax, arguments, return values, common patterns.

assistant: Direction
:   Determines whether to grow or shrink the curves. It can be toggled holding `Ctrl` while sculpting.

Scale Uniform
:   Grow or shrink curves by changing their size uniformly instead of using trimming or extrapolation.

Minimum Length
:   Avoid shrinking curves shorter than this length.
user: Describe Hints from the Blender manual or Python API, including usage steps and snippets.

assistant: Why would you use a lattice to deform a mesh instead of deforming the mesh itself in Edit Mode?
There are a couple of reasons for that:

- If your object has a large number of vertices, it would be difficult to edit portions of it quickly in Edit Mode.
  Using a lattice will allow you to deform large portions efficiently.
- The smooth deformation you get from a *Lattice* modifier can be hard to achieve manually.
- Multiple objects can use the same lattice, thus allowing you to edit multiple objects at once.
- Like all modifiers, it is non-destructive. Meaning all changes happen on top of the original geometry,
  which you can still go back to and edit without affecting the deformation.
- A lattice does not affect the texture coordinates of a mesh’s surface.
user: How do I use Creating a Soft Body in Blender? Include parameters, examples, warnings and best practices.

assistant: Soft body simulation works for all objects that have vertices or control points
(meshes, curves, surfaces, and lattices).

To add a soft body simulation to an object,
go to the *Physics* tab in the Properties and activate the *Soft Body* button.
For a reference of all the settings see [this page](settings/index.html).

You start a soft body simulation by playback animation with `Alt`-`A`,
and stop the simulation with `Esc` or `Alt`-`A`.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Image
:   Standard color input image.

Contrast
:   Adjusts the tonal contrast of the sepia effect.
    Higher values produce deeper shadows and brighter highlights,
    enhancing the image’s dynamic range.

Tone
:   Controls the hue of the sepia tint.
    Lower values shift the tone toward reddish-brown,
    while higher values create a more yellow or golden sepia appearance.

Saturation
:   Controls the intensity of the sepia color.
    A value of 0 results in a purely monochrome look,
    while higher values yield a richer, more pronounced color tint.
user: Describe Menus from the Blender manual or Python API, including usage steps and snippets.

assistant: Close Menu on Leave
:   Close menus when the mouse is moved out of the region.

### Open on Mouse Over

Select this to have the menu open by placing the mouse pointer over the entry instead of clicking on it.

Top Level
:   Time delay in 1/10 second before a menu opens (*Open on Mouse Over* needs to be enabled).

Sub Level
:   Same as above for sub menus (for example: File ‣ Open Recent).

### Pie Menus

Animation Timeout
:   Length of animation when opening Pie Menus.

Tap Key Timeout
:   Keystrokes held longer than this will dismiss the menu on release (in 1/100ths of a second).

Recenter Timeout
:   The window system tries to keep the pie menu within the window borders.
    Pie menus will use the initial mouse position as center for this amount of time, measured in 1/100ths of a second.
    This allows for fast dragged selections.

Radius
:   The size of the Pie Menu set with the distance (in pixels) of the menu items from the center of the pie menu.

Threshold
:   Distance from center before a selection can be made.

Confirm Threshold
:   Distance threshold after which selection is made (zero disables).
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Image
:   A colored output of the input image with the matte applied to only include selected layers.

Matte
:   A black-and-white alpha mask of the all the selected crypto layers.

Pick
:   A colored representation of the Cryptomatte pass which can be used
    with a Viewer node to select which crypto passes are used to create the matte image.
user: Give a detailed overview of Notes: syntax, arguments, return values, common patterns.

assistant: While the noise is random in nature, it follows a certain pattern that might not evaluate to
random values in some configurations. For instance, consider the following configuration
where a grid of objects have a material that evaluates a noise texture at their locations.
One might expect the objects to have random values since they have different locations,
but this is not the case.

[image reference removed]

An example configuration where the noise evaluates to a constant value.

It seems all objects have a value of 0.5. To understand why this happens, let us
look at the following plot of a 1D noise texture.

[image reference removed]

A plot of a 1D noise with zero details and zero distortion.

The horizontal line denotes a value of 0.5 and the vertical lines denotes whole numbers assuming
a noise scale of 1. As can be seen, the noise always intersects the 0.5 line at whole numbers.
Since the aforementioned objects were distributed on a grid and have whole number locations,
they all evaluate to 0.5. Which explains the issue at hand.

Generally, any discrete evaluation of noise at integer multiples of the reciprocal of
the noise scale will always evaluate to 0.5. It also follows that evaluations closer to
that will have values close to 0.5. In such cases, it is almost always preferred to use
the White Noise Texture.

Regardless, one can mitigate this issue in a number of ways:

- Adjust the scale of the noise to avoid aligning the noise with the evaluation domain.
- Add an arbitrary offset to the texture coordinates to break the alignment with the evaluation domain.
- Evaluate the noise at a higher dimension and adjust the extra dimension
  until a satisfactory result is achieved.

|  |  |
| --- | --- |
| ../../../_images/render_shader-nodes_textures_noise_issue-constant-value.png   Constant value issue. | ../../../_images/render_shader-nodes_textures_noise_solution1-constant-value.png   Mitigating the issue by adjusting the scale. |
| ../../../_images/render_shader-nodes_textures_noise_solution2-constant-value.png   Mitigating the issue by adding an arbitrary offset. | ../../../_images/render_shader-nodes_textures_noise_solution3-constant-value.png   Mitigating the issue by evaluating at a higher dimension. |

Similarly, in other configurations, one might experience some banding patterns in the noise,
where there are bands of high contrast areas followed by banding of low contrast areas.
For instance, planar surfaces that are slightly tilted along one of the axis
will have such a banding pattern.

[image reference removed]

An example configuration where the noise have a banding pattern.

This happens because the slight tilt along one of the axis causes values along
the perpendicular axis to change very slowly making the grid structure of
the noise more apparent. The easiest way to mitigate this issue to rotate
the coordinates by an arbitrary amount.

[image reference removed]

Mitigating the issue by rotating the coordinates by an arbitrary amount.
user: Provide the full official documentation entry for Particle Info Node, preserving all code examples.

assistant: # Particle Info Node

Cycles Only

[image reference removed]

The *Particle Info* node can be used in the material node tree for objects that are used as the instancing objects,
when you use *Object* or *Collection* [Render mode](../../../physics/particles/emitter/render.html) of a particle system.

This node gives access to the data of the particle that spawned the object instance.
It can be useful to give some variation to a single material assigned to multiple instances of instancing object.
user: What is Multiresolution and how is it used in Blender Python scripting?

assistant: The Multiresolution Modifier can be used for subdivision based sculpting.
This means the object will be subdivided, similar to the
[Subdivision Surface Modifier](../../../modeling/modifiers/generate/subdivision_surface.xhtml),
only that the subdivisions can be freely sculpted for very high resolution detailing.

[image reference removed]

This technique has the advantage of sculpting with multiple resolutions,
meaning you have the ability to sculpt on any level of subdivision.
This allows to add a much higher resolution of details for rendering and sculpting,
while displaying lower resolutions for better viewport performance.
It also allows sculpting on lower resolutions any time for broader changes.

As an example, you can sculpt general proportions in subdivision level 1,
add high resolution details in level 4 and switch back to subdivision 1 to correct the shape further.

The disadvantages are that you may end up with some mesh distortions
because the topology is not dynamic like voxel remeshing and dyntopo.
The topology should also not be changed once already subdivided,
since any edits to the base mesh will result in corrupted subdivision details.

Additional brushes like the [Multires Eraser](../brushes/multires_displacement_eraser.xhtml) and
[Multires Smear](../brushes/multires_displacement_smear.xhtml) are recommended for adjustments.

Here are general shortcuts to use the feature.

- Step up one multires level `Alt`-`2`
- Step down one multires level `Alt`-`1`
- Set multires level / Create multires modifier `Ctrl`-`0` to `Ctrl`-`5`
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: ### Keyframe Animation

This example shows you how to animate a cube’s location, rotation, and scale.

1. First, in the Timeline, or other animation editors, set the frame to 1.
2. With the cube selected in Object Mode, press `I` in the 3D Viewport.
   This will record the location, rotation, and scale, for the cube on frame 1.
3. Set the frame to 100.
4. Use Move `G`, Rotate `R`, Scale `S`, to transform the cube.
5. Press `I` in the 3D Viewport.

To test the animation, press `Spacebar` to play.

[image reference removed]

The animation on frames 1, 50 and 100.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

Force fields offer a way to influence a simulation, in example to add extra movement.
[Particles](../../particles/index.html), [Soft Bodies](../../soft_body/index.html),
[Rigid Bodies](../../rigid_body/index.html), and [Cloth objects](../../cloth/index.html)
can all be affected by forces fields.
Force fields automatically affect everything.
To remove a simulation or particle system from their influence,
simply turn down the influence of that type of force field in its Field Weights panel.

- All types of objects and particles can generate fields,
  but only curve object can bear a [Curve Guide](types/curve_guide.html) field.
- Force fields can also be generated from particles.
  See [Particle Physics](../../particles/emitter/physics/index.html).
- The objects need to share at least one common layer to have an effect.

You may limit the effect on particles to a group of objects
(see the [Particle Physics](../../particles/emitter/physics/index.html) page).
user: Explain Inherited Properties in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`NodeTreeInterfaceItem.item_type`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem.item_type "bpy.types.NodeTreeInterfaceItem.item_type") - [`NodeTreeInterfaceItem.parent`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem.parent "bpy.types.NodeTreeInterfaceItem.parent") | - [`NodeTreeInterfaceItem.position`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem.position "bpy.types.NodeTreeInterfaceItem.position") - [`NodeTreeInterfaceItem.index`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem.index "bpy.types.NodeTreeInterfaceItem.index") |
user: Give a detailed overview of Snap Element Items: syntax, arguments, return values, common patterns.

assistant: # Snap Element Items

INCREMENT:
:   Increment.

    Snap to increments.

GRID:
:   Grid.

    Snap to grid.

VERTEX:
:   Vertex.

    Snap to vertices.

EDGE:
:   Edge.

    Snap to edges.

FACE:
:   Face.

    Snap by projecting onto faces.

VOLUME:
:   Volume.

    Snap to volume.

EDGE_MIDPOINT:
:   Edge Center.

    Snap to the middle of edges.

EDGE_PERPENDICULAR:
:   Edge Perpendicular.

    Snap to the nearest point on an edge.

FACE_PROJECT:
:   Face Project.

    Snap by projecting onto faces.

FACE_NEAREST:
:   Face Nearest.

    Snap to nearest point on faces.
user: How do I use Color Palette in Blender? Include parameters, examples, warnings and best practices.

assistant: # Color Palette

[image reference removed]

Color Palette.

Color Palettes are a way of storing a brush’s color so that it can be used at a later time.
This is useful when working with several colors at once.

Palette
:   A [Data-Block Menu](data_block.xhtml#ui-data-block) to select a palette.

(New Pallet Color)
:   Adds the current brush’s primary *Color* to the palette.

(Delete Pallet Color)
:   Removes the currently selected color from the palette.

/ (Move Pallet Color)
:   Moves the selected color up/down one position.

(Sort By)
:   Sort Colors by Hue, Saturation, Value, Luminance.

Color List
:   Each color that belongs to the palette is presented in a list.
    Clicking on a color will change the brush’s primary *Color* to that color.
user: How do I use Dyntopo in Blender? Include parameters, examples, warnings and best practices.

assistant: # Dyntopo

Dynamic Topology (aka Dyntopo) can be toggled with the checkbox.
With dynamic topology active, most brushes will subdivide the mesh during the stroke.

For a general explanation of dynamic topology, visit
the [Introduction](../introduction/adaptive.xhtml).

Detail Size/Percentage, Resolution `R`
:   Each Detail Type’s detail is set here. Depending on the Detail Type being used
    this property will rather show as a pixel count (px), or percentage.

    `R` allows you to interactively set the detail, with a preview of the detail’s density in the 3D Viewport.

    Sample Detail Size
    :   When using *Constant Detail*, it is possible to sample the detail value of a certain mesh area
        by clicking the pipette icon next to the detail setting and then clicking on the area.

Refine Method
:   Setting the option will determine which of the methods will be used when altering the topology.

    Subdivide Edges:
    :   Just like the Subdivide tool, this method will only subdivide topology
        to match the detail given.

    Collapse Edges:
    :   When topology is too dense, and is smaller than the detail given, edges will
        be collapsed to fit the detail size appropriately.

    Subdivide Collapse:
    :   This method combines the two methods, subdividing edges smaller than
        the detail size, and collapsing topology.

Detailing
:   Dyntopo uses the following different detail methods to create dynamic detail on an object.

    Relative Detail:
    :   This method uses a detail size based on the number of pixels, and in turn
        will create topology in that size. Zoom out big details, zoom in small fine details.

    Constant Detail:
    :   To keep detail uniform across the entire object, Constant Detail can be used.
        The detail is a divisor of a Blender unit - higher values mean finer details.

    Brush Detail:
    :   Giving more control over the topology, with this method you can create topology
        based on the brush size. You can increase and lower topology by resizing the brush itself.
        The detail size is based the size of the brush itself,
        where full detail will create topology the size of the brush radius itself.

    Manual Detail:
    :   Similar to constant detail, this value sets a percentage value uniform across the object, but only
        applies detailing changes when using Flood Fill.

Detail Flood Fill `Ctrl`-`R`
:   When using *Constant* or *Manual* *Detailing*, this option is made available,
    allowing you to fill the entire object with a uniform detail, based on the resolution.