PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Draw Mode is the mode in Grease Pencil that allows you to draw in the 3D Viewport.
This mode is actually the only one in which new strokes can be created.

Already made strokes can not be selected in Draw Mode, for editing strokes you must use
the [Edit Mode](../edit/introduction.xhtml) or
[Sculpt Mode](../sculpting/introduction.xhtml).

[image reference removed]

3D Viewport Mode selector: Draw Mode.

Draw Mode is selected with the *Mode* menu in the 3D Viewport header.
Once Draw Mode is activated, the Toolbar of the 3D Viewport will change to Draw Mode specific panels.
Also a circle with the same color as the active material will appear and
follow the location of the cursor in the 3D Viewport.

To create new strokes you have to select one of the drawing tools in the Toolbar.
The most common one is the [Draw tool](tools.xhtml)
for free-hand drawings but there are many other tools for drawing, filling areas and erasing strokes.
There are also some tools to create primitives shapes like lines, arcs, curves, boxes and circles.

See [Toolbar](tools.xhtml) for more details.
user: Describe Mapping Type Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Mapping Type Items

POINT:
:   Point.

    Transform a point.

TEXTURE:
:   Texture.

    Transform a texture by inverse mapping the texture coordinate.

VECTOR:
:   Vector.

    Transform a direction vector (Location is ignored).

NORMAL:
:   Normal.

    Transform a unit normal vector (Location is ignored).
user: Explain Instancing in complete detail according to the official Blender documentation.

assistant: # Instancing

Vertices
:   This creates an instance of all children of this object on each vertex
    (for mesh objects only).

Faces
:   This creates an instance of all children of this object on each face
    (for mesh objects only).

Collection
:   This creates an instance of the collection with the transformation of the object.
    Collection instancers can be animated using actions,
    or can get a [Library Override](../../../../files/linked_libraries/library_overrides.xhtml).
user: Give a detailed overview of Quick Effects: syntax, arguments, return values, common patterns.

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.html) and built with
[Hair Node Groups](../modeling/geometry_nodes/hair/index.html) 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.html) node group.

Noise
:   Deforms hair curves using a noise texture.
    See the [Hair Curves Noise](../modeling/geometry_nodes/hair/deformation/hair_curves_noise.html) 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.html) node group for more information.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Image
:   The image to be processed.

Kernel
:   The convolution kernel used to modify the image.
    This can be provided as a constant value or an input image where pixel values define the kernel weights.

Normalize Kernel
:   A factor that determines whether the kernel values should be automatically normalized
    (i.e., divided by their total sum) to maintain consistent brightness.
user: Give a detailed overview of Mesh Access: syntax, arguments, return values, common patterns.

assistant: There are two ways to access BMesh data, you can create a new BMesh by converting a mesh from
[`bpy.types.BlendData.meshes`](bpy.types.BlendData.html#bpy.types.BlendData.meshes "bpy.types.BlendData.meshes") or by accessing the current Edit-Mode mesh.
See: `bmesh.types.BMesh.from_mesh` and [`bmesh.from_edit_mesh`](#bmesh.from_edit_mesh "bmesh.from_edit_mesh") respectively.

When explicitly converting from mesh data Python **owns** the data, that means that
the mesh only exists while Python holds a reference to it.
The script is responsible for putting it back into a mesh data-block when the edits are done.

Note that unlike `bpy`, a BMesh does not necessarily correspond to data in the currently open blend-file,
a BMesh can be created, edited and freed without the user ever seeing or having access to it.
Unlike Edit-Mode, the BMesh module can use multiple BMesh instances at once.

Take care when dealing with multiple BMesh instances since the mesh data can use a lot of memory.
While a mesh that the Python script owns will be freed when the script holds no references to it,
it’s good practice to call `bmesh.types.BMesh.free` which will remove all the mesh data immediately
and disable further access.

### Edit-Mode Tessellation

When writing scripts that operate on Edit-Mode data you will normally want to re-calculate the tessellation after
running the script, this needs to be called explicitly.
The BMesh itself does not store the triangulated faces, instead they are stored in the [`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh"),
to refresh tessellation triangles call [`bpy.types.Mesh.calc_loop_triangles`](bpy.types.Mesh.html#bpy.types.Mesh.calc_loop_triangles "bpy.types.Mesh.calc_loop_triangles").
user: Provide the full official documentation entry for Socket Syncing, preserving all code examples.

assistant: Closure nodes use socket names to match their inputs and outputs.
If two closure nodes are connected but have mismatched signatures, Blender can offer to sync them automatically.

- Sync happens automatically when a node is connected for the first time.
- Existing sockets are never changed automatically to avoid overwriting user data.
- A  button (*Sync Sockets*) button appears in the node header when a mismatch is detected, allowing manual synchronization.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Surface Input Type
:   Determines how the surface data is provided for interpolation.

    Object:
    :   Use an object reference to provide the surface.

    Geometry:
    :   Use a geometry input directly connected to the surface mesh.

Surface
:   The surface object used for generation.
    Its transforms must match those of the modifier object to ensure correct placement.

Surface UV Map
:   The UV map used to determine the root positions of the hair curves on the surface mesh.

Surface Rest Position
:   When enabled, sets the surface mesh to its rest position before generating the hair curves.
    This ensures consistent attachment locations when deforming the surface later.

Hair Length
:   The length of the generated hair curves.

Hair Material
:   The material assigned to the generated hair curves.

Control Points
:   The number of control points used for each generated curve.
    More points allow smoother deformations and finer control.

### Distribution

Distribution Method
:   Determines how the root points are distributed across the surface.

    Random:
    :   Places points randomly on the surface.

    Poisson Disk:
    :   Uses a Poisson disk distribution to ensure a minimum spacing between points.
        See [Distribute Points on Faces](../../point/distribute_points_on_faces.xhtml) for more details.

Density
:   Controls the number of generated hair curves per surface area.
    Higher values produce denser hair coverage.

Density Mask
:   A scalar factor that modulates the density across the surface.
    This allows certain regions to have more or fewer generated curves.

Mask Texture
:   An image texture used to discard curves based on pixel values sampled with the *Surface UV Map* input.
    White areas retain curves, while black areas remove them.

Viewport Amount
:   A factor applied to reduce curve density in the viewport for better performance,
    without affecting the final render.

Seed
:   Sets the random seed for the distribution process.
    Changing this value alters the pattern of generated curves while maintaining the same parameters.
user: Show practical ways to work with Resize in a Blender add-on or script – include code.

assistant: Adjusts the image dimensions by scaling its pixel resolution. This is useful for various tasks, such as:

- Reducing texture resolution to optimize performance and memory usage.
- Increasing image resolution for more detailed painting or editing.

Size X, Y
:   Defines the new width and height of the image in pixels.

All UDIM Tiles
:   Applies the resizing operation to all UDIM tiles in the image.
user: How do I use Surface Primitives in Blender? Include parameters, examples, warnings and best practices.

assistant: # Surface Primitives

The *Add Surface* menu offers the following primitives:

|  |  |
| --- | --- |
| ../../_images/modeling_surfaces_primitives_curve.png   NURBS curve primitives. | ../../_images/modeling_surfaces_primitives_surface.png   NURBS surface primitives. |

NURBS Curve
:   Adds a simple curve of four control points forming an arc.

NURBS Circle
:   Adds a closed loop of control points forming a circle.

NURBS Surface
:   Adds a simple surface patch consisting of a 4×4 grid with the center points slightly raised.

NURBS Cylinder
:   Adds an open cylinder, consisting of an extruded *NURBS Circle*.

NURBS Sphere
:   Adds a generic sphere constructed from control points arranged in a cube.

NURBS Torus
:   Adds a doughnut-shaped primitive created by rotating a circle around an axis.
user: What is Index Buffers and how is it used in Blender Python scripting?

assistant: Often triangles and lines share one or more vertices.
With only a vertex buffer one would have to store all attributes for the these vertices multiple times.
This is very inefficient because in a connected triangle mesh every vertex is used 6 times on average.
A more efficient approach would be to use an *Index Buffer* (IBO) ([`gpu.types.GPUIndexBuf`](gpu.types.html#gpu.types.GPUIndexBuf "gpu.types.GPUIndexBuf")),
sometimes referred to as *Element Buffer*.
An *Index Buffer* is an array that references vertices based on their index in the vertex buffer.

For instance, to draw a rectangle composed of two triangles, one could use an index buffer.

```
positions = (
    (-1,  1), (1,  1),
    (-1, -1), (1, -1))

indices = ((0, 1, 2), (2, 1, 3))

ibo = gpu.types.GPUIndexBuf(type='TRIS', seq=indices)
```

Here the first tuple in `indices` describes which vertices should be used for the first triangle
(same for the second tuple).
Note how the diagonal vertices 1 and 2 are shared between both triangles.
user: Give a detailed overview of Viewport Preview: syntax, arguments, return values, common patterns.

assistant: Before rendering your scene, you can save a Viewport Preview of the animation for testing in the final display.
In the Render Output panel you can choose the output *Views Format*.

The options include individual files per view, top-bottom, anaglyph among others.
Pick the one that fits your display requirements.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`Scene.sequence_editor`](bpy.types.Scene.html#bpy.types.Scene.sequence_editor "bpy.types.Scene.sequence_editor") | - [`Scene.sequence_editor_create`](bpy.types.Scene.html#bpy.types.Scene.sequence_editor_create "bpy.types.Scene.sequence_editor_create") |
user: What is Options and how is it used in Blender Python scripting?

assistant: [[image reference removed]](../../../_images/modeling_modifiers_modify_weight-edit_panel.png)

The Vertex Weight Edit modifier panel.

Vertex Group
:   The vertex group to affect.

Default Weight
:   The default weight to assign to all vertices not in the given vertex group.

Group Add
:   Adds vertices with a final weight over *Add Threshold* to the vertex group.

Group Remove
:   Removes vertices with a final weight below *Remove Threshold* from the vertex group.

Normalize Weights
:   Scale the weights in the vertex group to keep the relative weight
    but the lowest and highest values follow the full 0 - 1 range.

### Falloff

Falloff Type
:   Type of mapping.

    Linear
    :   No mapping.

    Custom Curve
    :   Allows you to manually define the mapping using a curve.

    Sharp, Smooth, Root and Sphere
    :   These are classical mapping functions, from spikiest to roundest.

    Random
    :   Uses a random value for each vertex.

    Median Step
    :   Creates binary weights (0.0 or 1.0), with 0.5 as cutting value.

Invert
:   Inverts the falloff.

### Influence

Those settings are the same for the three *Vertex Weight* modifiers.

Global Influence
:   The overall influence of the modifier
    (0.0 will leave the vertex group’s weights untouched, 1.0 is standard influence).

In addition, a per-vertex fine control of the effect is possible using either a vertex group or a texture
(both are mutually exclusive). The per-vertex values from those will be multiplied with the *Global Influence*.

See [common masking options](../common_options.html#modifiers-common-options-masking) for a complete reference.
user: Show practical ways to work with D in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [**Data User**](glossary/index.xhtml#term-Data-User) - [**Data-Block**](glossary/index.xhtml#term-Data-Block) - [**Depth of Field**](glossary/index.xhtml#term-Depth-of-Field) - [**Dielectric Material**](glossary/index.xhtml#term-Dielectric-Material) - [**Diffuse Light**](glossary/index.xhtml#term-Diffuse-Light) - [**Directional Light**](glossary/index.xhtml#term-Directional-Light) | - [**Displacement Mapping**](glossary/index.xhtml#term-Displacement-Mapping) - [**Display Referenced**](glossary/index.xhtml#term-Display-Referenced) - [**DOF**](glossary/index.xhtml#term-DOF) - [**Dots Per Inch**](glossary/index.xhtml#term-Dots-Per-Inch) - [**Double Buffer**](glossary/index.xhtml#term-Double-Buffer) - [**DPI**](glossary/index.xhtml#term-DPI) |
user: Give a detailed overview of Asset Shelf Region: syntax, arguments, return values, common patterns.

assistant: Depending on the current mode, the asset shelf may be available, providing quick access to assets
for this specific mode (for example pose assets in *Pose Mode*, brush assets in *Sculpt Mode*).

See [Asset Shelf](../../interface/window_system/regions.xhtml#ui-region-asset-shelf) for more information.
user: Show practical ways to work with Principled Volume in a Blender add-on or script – include code.

assistant: # Principled Volume

[image reference removed]

The *Principled Volume* shader combines all volume shading components into
a single easy to use node. Volumes like smoke and fire can be rendered with
a single shader node, which includes scattering, absorption and blackbody emission.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Vector
:   Vector of the input system that is to be divided into radial segments.

Sides
:   Number of radial segments to divide the input coordinate system into.
    A non-integer value results in an irregular segment that is smaller than the regular segments.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_0.png   Sides: 5.0. | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_25.png   Sides: 5.25. | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_5.png   Sides: 5.5. | ../../../../_images/render_shader-nodes_radial_tiling_segments-6_0.png   Sides: 6.0. |

Roundness
:   Roundness of the segment coordinate systems.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_0.png   Roundness: 0.0. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_25.png   Roundness: 0.25. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_5.png   Roundness: 0.5. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-1_0.png   Roundness: 1.0. |
user: Describe Combine Spherical Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Combine Spherical Node

[image reference removed]

The *Combine Spherical* node converts spherical coordinates (R, Φ, Θ)
into a Cartesian vector (X, Y, Z). It is the inverse of the
[Separate Spherical](separate_spherical.xhtml) node.

Spherical coordinates represent a point in 3D space by its distance from the origin,
horizontal rotation, and vertical inclination, which can be useful for constructing
radial or rotational patterns and generating coordinates on a sphere.
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") - [`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: Provide the full official documentation entry for FunctionNodeReplaceString(FunctionNode), preserving all code examples.

assistant: # FunctionNodeReplaceString(FunctionNode)

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

*class* bpy.types.FunctionNodeReplaceString(*FunctionNode*)
:   Replace a given string segment with another

    *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 Field to Grid Node and how is it used in Blender Python scripting?

assistant: # Field to Grid Node

[image reference removed]

The *Field to Grid* node creates one or more new voxel grids by evaluating
geometry fields on the topology of an existing grid.
This allows generating new volumetric data (such as density, temperature,
velocity, or distance fields) directly from field inputs defined in the node
tree.

Each input field is sampled at the voxel positions of the provided topology
grid, producing a corresponding output grid that matches the same resolution,
transform, and domain.
This enables consistent evaluation of multiple attributes or procedural
quantities across the same volume structure.
user: Provide the full official documentation entry for Adding/Removing/Moving Files, preserving all code examples.

assistant: When RST-files are added or removed the corresponding locale files are added or removed automatically by the update
script. However, if files need to be moved please use this Python script:

```
python tools/utils_maintenance/rst_remap.py start
```

RST-files can then be freely moved and the remap script will move the locale file after:

```
python tools/utils_maintenance/rst_remap.py finish
```

It is best to avoid moving/renaming files as this breaks URLs and without this script translators will lose all their
work in these files. Please ask an administrator if you think something should be renamed/moved.
user: Provide the full official documentation entry for BlendDataArmatures(bpy_struct), preserving all code examples.

assistant: # BlendDataArmatures(bpy_struct)

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

*class* bpy.types.BlendDataArmatures(*bpy_struct*)
:   Collection of armatures

    new(*name*)
    :   Add a new armature to the main database

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the data-block

        Returns:
        :   New armature data-block

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

    remove(*armature*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove an armature from the current blendfile

        Parameters:
        :   - **armature** ([`Armature`](bpy.types.Armature.html#bpy.types.Armature "bpy.types.Armature"), (never None)) – Armature to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this armature before deleting it (WARNING: will also delete objects instancing that armature data)
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this armature data
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this armature data

    tag(*value*)
    :   tag

        Parameters:
        :   **value** (*boolean*) – Value

    *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 Is Spline Cyclic Node: syntax, arguments, return values, common patterns.

assistant: # Is Spline Cyclic Node

[image reference removed]

The *Is Spline Cyclic* controls whether each of the curve splines start and endpoints form a connection.
Its output corresponds to the built-in `cyclic` attribute on the curve spline domain.

The node to set this data is the [Set Spline Cyclic Node](../write/set_spline_cyclic.xhtml).
user: Explain Properties in complete detail according to the official Blender documentation.

assistant: Transform Space
:   The transformation of the vector and geometry outputs.

    Original:
    :   Output the geometry relative to the input object transform, and the location,
        rotation and scale relative to the world origin.

    Relative:
    :   Bring the input object geometry, location, rotation and scale into the modified object,
        maintaining the relative position between the two objects in the scene.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Type
:   The type of angle input.

    X/Y/Z Axis:
    :   Rotates the vector around the defined axis and
        the amount of rotation is defined by the *Angle* input.

    Axis Angle:
    :   Rotates the vector around an arbitrary axis defined by the *Axis* input vector.
        The amount of rotation is defined by the *Angle* input.

    Euler:
    :   Rotates the vector about a center point defined by the *Center* input vector.
        The amount of rotation on each axis is defined by the *Rotation* input vector.

Invert
:   Inverts the rotation angle.
user: What is Exporting to USD Files and how is it used in Blender Python scripting?

assistant: Universal Scene Description (USD) files can contain complex layering, overriding, and references to other files.
Blender’s USD Exporter takes a much simpler approach. When exporting, all visible, supported objects in
the scene are exported, optionally limited by their selection state. Blender does not (yet) support exporting
invisible objects, USD layers, variants, etc.

The following objects can be exported to USD:

- Meshes (of different kinds, see below).
- Cameras (perspective cameras only at the moment, not orthogonal ones).
- Curves
- Text (exported as meshes).
- Lights
- Hair (exported as curves, and limited to parent strands).
- Point Clouds
- Metaballs (exported as animated meshes).
- Volumes
- Armatures

When exporting an animation, the final, evaluated mesh is written to USD.
This means that the following meshes can be exported:

- Static meshes.
- Deforming meshes; here the topology of the mesh does not change,
  but the locations of the vertices change over time. Examples are animated characters or
  bouncing (but not cracking) objects.
- Arbitrarily animated meshes; here the topology does change.
  An example is the result of a fluid simulation, where splashes of fluid can break off the main body.

[image reference removed]

Shot from [Spring](https://studio.blender.org/films/spring/) exported to USD and opened in USDView.
user: Explain Circle in complete detail according to the official Blender documentation.

assistant: Adds a flat, 2D ring of vertices forming a polygonal approximation of a circle.
This primitive is useful as a starting point for cylindrical objects, holes, pipe ends,
or extrusion-based modeling workflows.

Vertices
:   Number of vertices used to define the perimeter of the circle.
    Higher values result in a smoother shape.

Fill Type
:   Sets how the center of the circle is filled:

    Triangle Fan:
    :   Fills the circle with triangular faces sharing a central vertex.

    N-gon:
    :   Fills the center with a single N-gon face.

    Nothing:
    :   Leaves the circle unfilled; only the perimeter vertices are created.

Radius
:   Distance from the center to the outer edge of the circle.
user: Show practical ways to work with Connect Vertex Pairs in a Blender add-on or script – include code.

assistant: # Connect Vertex Pairs

This operator connects selected vertices by creating edges between them and splitting the face.
It can be used on many faces at once.

|  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_meshes_editing_vertex_connect-vertex-pairs_before.png   Vertices before connecting. | ../../../../_images/modeling_meshes_editing_vertex_connect-vertex-pairs_after.png   After connecting vertices. | ../../../../_images/modeling_meshes_editing_vertex_connect-vertex-pairs_after-faces.png   Resulting face pair. |

The main difference between this operator and [Connect Vertex Path](connect_vertex_path.xhtml)
is that this operator ignores the selection order and connects all selected vertices that share a face.
user: Describe Sculpting Brushes from the Blender manual or Python API, including usage steps and snippets.

assistant: # Sculpting Brushes

Brushes for Grease Pencil *Sculpt* mode bundled in the *Essentials* library.
See [Brush](tool_settings/brush.xhtml) for more information.

[image reference removed]

Smooth Stroke
:   Eliminates irregularities in the area of the drawing
    within the brush’s influence by smoothing the positions of the points.

Thickness Stroke
:   Increase or decrease the points thickness in the area of the drawing
    within the brush’s influence.

Strength Stroke
:   Increase or decrease the points transparency (alpha) in the area of the drawing
    within the brush’s influence.

Randomize Stroke
:   Add noise to the strokes in the area of the drawing
    within the brush’s influence by moving points location in a random way.

Grab Stroke
:   Used to drag a group of points around. Unlike the other brushes,
    Grab does not modify different points as the brush is dragged across the model.
    Instead, Grab selects a group of points on mouse-down, and pulls them to follow the mouse.
    The effect is similar to moving a group of points in Edit Mode with Proportional Editing enabled.

Pull Stroke
:   Moves points in the direction of the brush stroke.

Twist Stroke
:   Twist the points in counter-clockwise (CCW) or Clockwise (CW) rotation.

Pinch Stroke
:   Pulls points towards the center of the brush.
    The inverse setting is Inflate, in which points are pushed away from the center of the brush.

Clone Stroke
:   Adds copies of the strokes in the clipboard in the center of the brush.
    You have to copy the selected strokes you want into the clipboard with `Ctrl`-`C` before using the tool.
user: Give a detailed overview of Geometry: syntax, arguments, return values, common patterns.

assistant: # Geometry

[image reference removed]

Geometry panel.

The Geometry panel lets you turn a curve from a 1D line into a 2D ribbon or a 3D tube.

[image reference removed]

Three copies of the same base curve: one without geometry (bright orange line);
one with Offset and Extrude applied (blue ribbon); and one with Offset, Extrude,
and Bevel applied (gray tube).

Offset
:   Moves the control points along their normals.

Extrude
:   Turns the curve from a line into a ribbon by extruding it to the “sides”:
    at each point, the curve normal is calculated as the “up” direction,
    and the curve is extruded to the “left” and “right.”

Taper Object
:   A separate Curve object, consisting of a single, non-[cyclic](../editing/curve.html#bpy-ops-curve-cyclic-toggle),
    2D spline, that controls the scale factor of the geometry along the length of each of the curve’s splines.

    Specifically, the *Taper Object* defines a graph where the X axis represents the position on the
    curve and the Y axis represents the scale:

    - The first control point of the *Taper Object* spline corresponds to the first control point of
      each geometry spline. Same thing for the last points.
    - The first *Taper* point should have the highest X coordinate, and the last point the lowest
      (try [Switch Direction](../editing/segments.html#bpy-ops-curve-switch-direction) if the scaling doesn’t seem to be working).
      The specific range of X coordinates doesn’t matter: it could be [-10, 10], [-1, 1], or anything else.
    - A Y coordinate of 1.0 leaves the geometry unchanged. A coordinate of 0.5 makes it half as large,
      while 2.0 makes it twice as large.

    The Z coordinates of the *Taper Object* control points are ignored, but if you want,
    you can set the object’s [Shape](shape.html#bpy-types-curve-dimensions) to “2D” to force them to 0.

Taper Radius
:   How to combine the scale graph of the *Taper Object* with the radii of the control points.

    Override:
    :   The *Taper Object* (scale curve) overrides the radii (scales) of the curve’s control points.

    Multiply:
    :   The scale given by the *Taper Object* is multiplied by that of the control points.

    Add:
    :   The scale given by the *Taper Object* is added to that of the control points.

    Examples of a curve with a Radius of 0 on the left and 1 on the right.

    |  |  |  |
    | --- | --- | --- |
    | ../../../_images/modeling_curves_properties_geometry_taper-mode-override.png   Override mode. | ../../../_images/modeling_curves_properties_geometry_taper-mode-multiply.png   Multiply mode. | ../../../_images/modeling_curves_properties_geometry_taper-mode-add.png   Add mode. |

Map Taper
:   If geometry is only generated for part of the curve (which can be achieved by changing
    [Factor Start/End](#bpy-types-curve-bevel-factor-start)), enabling *Map Taper* will
    make the endpoints of the *Taper Object* correspond to those of the geometry instead of
    those of the curve.
user: Explain Volume to Mesh Modifier in complete detail according to the official Blender documentation.

assistant: # Volume to Mesh Modifier

This modifier is the inverse of the *Mesh to Volume* modifier.
It takes an existing volume object and converts one of its grids to a mesh.
Only scalar grids (such as the density grid) can be converted.
user: Describe Rip Vertices from the Blender manual or Python API, including usage steps and snippets.

assistant: # Rip Vertices

Rip creates a “hole” in the mesh by making a copy of selected vertices and edges,
still linked to the neighboring non-selected vertices,
so that the new edges are borders of the faces on one side, and the old ones,
borders of the faces on the other side of the rip.
user: Give a detailed overview of Bone Collections: syntax, arguments, return values, common patterns.

assistant: # Bone Collections

[Bone Collections](../../../glossary/index.html#term-Bone-Collection) group the bones of an
[Armature](../../../glossary/index.html#term-Armature) into named collections. The armature is the owner of these
collections, so they are available in all modes. Bone Collections are identified
by their name, which are unique within the Armature.
Bone Collections can be nested inside other Bone Collections to create an organized hierarchy for complex rigs.

In the text below, “collection” is understood to refer to “bone collection”;
[Scene Collections](../../../glossary/index.html#term-Collection) are not described here.

Bone Collections can be managed via [the Armature and Bone property panels](../properties/bone_collections.html#bpy-types-bonecollection).
user: Show practical ways to work with Inherited Properties in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleThicknessModifier.name`](bpy.types.LineStyleThicknessModifier.html#bpy.types.LineStyleThicknessModifier.name "bpy.types.LineStyleThicknessModifier.name") |
user: How do I use Dependency graph: Object.to_mesh() in Blender? Include parameters, examples, warnings and best practices.

assistant: Function to get a mesh from any object with geometry. It is typically used by exporters, render
engines and tools that need to access the evaluated mesh as displayed in the viewport.

Object.to_mesh() is closely interacting with dependency graph: its behavior depends on whether it
is used on original or evaluated object.

When is used on original object, the result mesh is calculated from the object without taking
animation or modifiers into account:

- For meshes this is similar to duplicating the source mesh.
- For curves this disables own modifiers, and modifiers of objects used as bevel and taper.
- For meta-balls this produces an empty mesh since polygonization is done as a modifier evaluation.

When is used on evaluated object all modifiers are taken into account.

```
import bpy

class OBJECT_OT_object_to_mesh(bpy.types.Operator):
    """Convert selected object to mesh and show number of vertices"""
    bl_label = "DEG Object to Mesh"
    bl_idname = "object.object_to_mesh"

    def execute(self, context):
        # Access input original object.
        obj = context.object
        if obj is None:
            self.report({'INFO'}, "No active mesh object to convert to mesh")
            return {'CANCELLED'}
        # Avoid annoying None checks later on.
        if obj.type not in {'MESH', 'CURVE', 'SURFACE', 'FONT', 'META'}:
            self.report({'INFO'}, "Object cannot be converted to mesh")
            return {'CANCELLED'}
        depsgraph = context.evaluated_depsgraph_get()
        # Invoke to_mesh() for original object.
        mesh_from_orig = obj.to_mesh()
        self.report({'INFO'}, f"{len(mesh_from_orig.vertices)} in new mesh without modifiers.")
        # Remove temporary mesh.
        obj.to_mesh_clear()
        # Invoke to_mesh() for evaluated object.
        object_eval = obj.evaluated_get(depsgraph)
        mesh_from_eval = object_eval.to_mesh()
        self.report({'INFO'}, f"{len(mesh_from_eval.vertices)} in new mesh with modifiers.")
        # Remove temporary mesh.
        object_eval.to_mesh_clear()
        return {'FINISHED'}

def register():
    bpy.utils.register_class(OBJECT_OT_object_to_mesh)

def unregister():
    bpy.utils.unregister_class(OBJECT_OT_object_to_mesh)

if __name__ == "__main__":
    register()
```
user: Show practical ways to work with Wireframe Modifier in a Blender add-on or script – include code.

assistant: # Wireframe Modifier

The *Wireframe* modifier transforms a mesh into a wireframe by iterating over its
faces, collecting all edges and turning those edges into four-sided polygons.
Be aware of the fact that your mesh needs to have faces to be wireframed.
You can define the thickness, the material and several other parameters of the generated
wireframe dynamically via the given modifier options.
user: Explain High Viscosity Solver in complete detail according to the official Blender documentation.

assistant: The high viscosity liquid solver can be used to simulate fluids with increased viscosity,
replicating the behavior of substances like honey or molasses.
This specialized solver enhances the accuracy of slow-moving and thick liquid simulations.

Strength
:   The viscosity of the liquid. Higher values result in more viscous fluids.

    Rotating liquid inflow with varying viscosities.

    |  |  |
    | --- | --- |
    | ../../../../../_images/physics_fluid_type_domain_liquid_viscosity_0-2.png   Strength of 0.2 (at frame 65). | ../../../../../_images/physics_fluid_type_domain_liquid_viscosity_0-4.png   Strength of 0.4 (at frame 200). |
user: Provide the full official documentation entry for GeometryNodeTrimCurve(GeometryNode), preserving all code examples.

assistant: # GeometryNodeTrimCurve(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.GeometryNodeTrimCurve(*GeometryNode*)
:   Shorten curves by removing portions at the start or end

    mode
    :   How to find endpoint positions for the trimmed spline

        - `FACTOR`
          Factor – Find the endpoint positions using a factor of each spline’s length.
        - `LENGTH`
          Length – Find the endpoint positions using a length from the start of each spline.

        Type:
        :   enum in [`'FACTOR'`, `'LENGTH'`], default `'FACTOR'`

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

assistant: The Video Sequencer is composed of multiple regions.
They are described in more detail in the next sections.
Figure 1 shows the combined *Sequencer & Preview* view type:

[image reference removed]

Figure 1: The Video Sequencer Editor shown in the Sequencer & Preview view type.

Header
:   Contains menus and buttons for interacting with the editor.
    The header changes slightly depending on the selected view type (see below).

Footer
:   Contains menus and buttons for interacting with animation playback.

Preview
:   Shows the output of the Sequencer at the time of the Playhead.

Sequencer
:   Shows a timeline for managing the montage of strips.

Sidebar
:   Shows the properties of the active strip.
    It’s divided into panels and tabs. Toggle on or off with `N`.

Toolbar
:   Shows a list of tools. Toggle on or off with `T`.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Mesh
:   Standard geometry input.

Selection
:   A standard Boolean selection input to determine which faces will be triangulated.

Quad Method
:   Beauty:
    :   Split the quads in nice triangles, slower method.

    Fixed:
    :   Split the quads on their 1st and 3rd vertices.

    Fixed Alternate:
    :   Split the quads on their 2nd and 4th vertices.

    Shortest Diagonal:
    :   Split the quads along their shortest diagonal.

    Longest Diagonal:
    :   Split the quads along their longest diagonal. This is the preferred mode for cloth simulations.

N-gon Method
:   Beauty:
    :   Arrange the new triangles nicely, slower method.

    Clip:
    :   Split n-gons using an ear-clipping algorithm
        (the same method of tessellation used for viewport display).
user: Describe Navigation Bar from the Blender manual or Python API, including usage steps and snippets.

assistant: Properties are grouped into tabs, shown as a vertical list of icons in the Navigation Bar region of the editor.

The Navigation Bar can be flipped to the left or right of the editor by `RMB` on the region and selecting
Navigation Bar ‣ Flip to Left/Right.

To hide the Navigation Bar, `RMB` on the region and select Navigation Bar ‣ Hide.
Use the region toggle icon as described in [Changing the Size and Hiding Regions](../interface/window_system/regions.xhtml#bpy-ops-screen-region-blend).

### Active Tool and Workspace Settings

This first tab contains settings for the active [tool](3dview/toolbar/index.xhtml) (in the 3D Viewport)
and the current [workspace](../interface/window_system/workspaces.xhtml).

### Scene

Tabs related to the active scene:

- Render: [EEVEE](../render/eevee/index.xhtml),
  [Cycles](../render/cycles/render_settings/index.xhtml), or
  [Workbench](../render/workbench/index.xhtml) settings.
- [Output](../render/output/index.xhtml)
- [View Layer](../render/layers/index.xhtml)
- [Scene](../scene_layout/scene/properties.xhtml)
- [World](../render/lights/world.xhtml)

### Collection

Settings for the active [Collection](../scene_layout/collections/collections.xhtml#scene-layout-collections-collections-tab).

### Object

Tabs related to the active object. Some are only shown for certain object types.

- [Object](../scene_layout/object/properties/index.xhtml)
- [Modifiers](../modeling/modifiers/index.xhtml) (or [Grease Pencil Modifiers](../grease_pencil/modifiers/index.xhtml))
- [Effects](../grease_pencil/visual_effects/index.xhtml)
- [Particles](../physics/particles/index.xhtml)
- [Physics](../physics/index.xhtml)
- [Object Constraints](../animation/constraints/index.xhtml)

### Object Data

The *Object Data* tab name remains constant, but its icon changes depending on the object type.

Geometry Objects

- [Mesh](../modeling/meshes/properties/object_data.xhtml)
- [Curve](../modeling/curves/properties/index.xhtml)
- [Surface](../modeling/surfaces/properties/index.xhtml)
- [Text](../modeling/texts/properties.xhtml)
- [Metaball](../modeling/metas/properties.xhtml)
- [Grease Pencil](../grease_pencil/properties/index.xhtml)

Rigging and Deformation Objects

- [Armature](../animation/armatures/properties/index.xhtml)

  - [Bone](../animation/armatures/bones/properties/index.xhtml)
  - [Bone Constraints](../animation/armatures/posing/bone_constraints/index.xhtml)
- [Lattice](../animation/lattice.xhtml)

Other Object Types

- [Empty](../modeling/empties.xhtml)
- [Speaker](../render/output/audio/speaker.xhtml)
- [Camera](../render/cameras.xhtml)
- [Light](../render/lights/light_object.xhtml)
- [Light Probe](../render/eevee/light_probes/index.xhtml)

### Object Shading

Tabs related to an object’s visual appearance. Shown only when relevant.

- [Material](../render/materials/index.xhtml)
- [Texture](../render/materials/legacy_textures/index.xhtml)

### Strips

Tabs related to video editing strips. Shown only when relevant.

- [Strip Modifiers](../video_editing/edit/montage/strip_modifiers.xhtml)
user: How do I use Basic Panel Example in Blender? Include parameters, examples, warnings and best practices.

assistant: This script is a simple panel which will draw into the object properties
section.

Notice the ‘CATEGORY_PT_name’ [`Panel.bl_idname`](#bpy.types.Panel.bl_idname "bpy.types.Panel.bl_idname"), this is a naming
convention for panels.

```
import bpy

class HelloWorldPanel(bpy.types.Panel):
    bl_idname = "OBJECT_PT_hello_world"
    bl_label = "Hello World"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"

    def draw(self, context):
        self.layout.label(text="Hello World")

bpy.utils.register_class(HelloWorldPanel)
```