PGCRYPT/OpenBlender_Train huggingface dataset:
user: Provide the full official documentation entry for Extrude, preserving all code examples.

assistant: # Extrude

When you press `E`, for each selected tip
(either explicitly or implicitly), a new bone is created.
This bone will be the child of “its” tip owner, and connected to it. As usual,
once extrusion is done, only the new bones’ tips are selected, and in select mode,
so you can place them to your liking. See Fig. [Extrusion example.](#fig-rig-bones-extrusion).

Extrusion example.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_editing_extrude_example-1.png   An armature with three selected tips. | ../../../../_images/animation_armatures_bones_editing_extrude_example-2.png   The three extruded bones. |

You also can use the rotating/scaling extrusions,
as with meshes, by pressing respectively `E` `R` and `E` `S` –
as well as [locked](../../../../scene_layout/object/editing/transform/control/axis_locking.xhtml)
extrusion along a global or local axis.

Mirror extrusion example.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_editing_extrude_mirror-1.png   A single selected bone’s tip. | ../../../../_images/animation_armatures_bones_editing_extrude_mirror-2.png   The two mirror-extruded bones. |

Bones have an extra “mirror extruding” tool, called by pressing `Shift`-`E`.
By default, it behaves exactly like the standard extrusion.
But once you have enabled [X-Axis Mirror](../tools/tool_settings.xhtml#bpy-types-armature-use-mirror-x) editing option,
each extruded tip will produce *two new bones*, having the same name except for the “_L”/ “_R” suffix
(for left/right, see the [naming conventions](naming.xhtml#armature-editing-naming-conventions)).
The “_L” bone behaves like the single one produced by the default extrusion –
you can move, rotate or scale it exactly the same way.
The “_R” bone is its mirror counterpart (along the armature’s local X axis),
see Fig. [Mirror extrusion example.](#fig-rig-bone-mirror).

In case you are wondering, you cannot just press `X` to solve this as you would in mesh editing,
because extrusion selects the newly created tips, and as explained below the Delete tool ignores bones’ joints.
To get rid of these extruded bones without undoing, you would have to move the tips,
then select the bones and [delete](delete.xhtml#bpy-ops-armature-delete) them.
user: Provide the full official documentation entry for ShaderNodeUVAlongStroke(ShaderNode), preserving all code examples.

assistant: # ShaderNodeUVAlongStroke(ShaderNode)

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

*class* bpy.types.ShaderNodeUVAlongStroke(*ShaderNode*)
:   UV coordinates that map a texture along the stroke length

    use_tips
    :   Lower half of the texture is for tips of the stroke

        Type:
        :   boolean, default False

    *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: Describe Transform Modal Map from the Blender manual or Python API, including usage steps and snippets.

assistant: # Transform Modal Map

During a transformation, some hotkeys can change the behavior of the operation.

You can check editing the keys of these modal modifiers in
Blender Preferences ‣ Keymap ‣ Transform Modal Map
(at the bottom of the keymap).
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Method
:   The algorithm used to compute the tangents:

    Exact:
    :   Uses the *MikkTSpace* algorithm for tangent computation.
        Produces consistent and accurate results that match the tangents used in
        Blender’s shading system and exported geometry.
        This method ensures that tangents align with the normal map space used in rendering.

    Fast:
    :   A faster approximate method that interpolates tangents across face corners with matching UVs.
        It provides similar results at a much lower computational cost but may
        produce less consistent results on complex or uneven surfaces.
        For an exact tangent aligned to the surface, the cross product of the
        result with the surface normal can be used.

UV
:   The UV map used to calculate the tangent direction.
    The UV coordinates define how the tangent vectors are oriented across the surface.
user: Give a detailed overview of Bilateral Blur Node: syntax, arguments, return values, common patterns.

assistant: # Bilateral Blur Node

[image reference removed]

The Bilateral Blur node performs a high-quality adaptive blur, blurring
the image while retaining sharp edges.

It can be used for various purposes like: smoothing noisy render passes to avoid longer computation times
in example ray-traced ambient occlusion, blurry refractions/reflections, soft shadows,
or to make non-photorealistic compositing effects.
user: Show practical ways to work with Transform in a Blender add-on or script – include code.

assistant: Flip Horizontally
:   Mirrors the image so the left side becomes the right side.

Flip Vertically
:   Mirrors the image so the top becomes the bottom.

Rotate 90° Clockwise
:   Rotates the image clockwise 90°.

Rotate 90° Counter-Clockwise
:   Rotates the image counter-clockwise 90°.

Rotate 180°
:   Rotates the image 180°.
user: How do I use Curve Tilt Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Curve Tilt Node

[image reference removed]

The *Curve Tilt* node outputs the angle used to turn the curve normal
around the direction of the curve tangent in its evaluated points.
Keep in mind that the output is per control point, just like the values
that can be controlled in curve Edit Mode. For NURBS and Bézier splines,
the values will be interpolated to the final evaluated points.

The input node for this data is the [Set Curve Tilt](../write/set_curve_tilt.xhtml) node.
user: Provide the full official documentation entry for Pack Data, preserving all code examples.

assistant: ### Pack Resources

Mark all eligible external resource files used by the blend-file as packed.
Actual packing will happen on the next save of the blend-file.

### Automatically Pack Resources

When enabled, this option will ensure that all eligible external resource files, existing or added later,
are systematically marked as packed.
As with *Pack Resources*, the blend-file must be saved to the drive for this to have an effect.

Disabling that option won’t unpack anything, but future external files
won’t be automatically marked as packed anymore.

### Selective Packing

A single file can be packed by clicking on the little “gift box” icon to the left of its file-path UI widget.
user: Describe Color Palette from the Blender manual or Python API, including usage steps and snippets.

assistant: 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](../../interface/controls/templates/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: Explain Merge by Distance Node in complete detail according to the official Blender documentation.

assistant: # Merge by Distance Node

[image reference removed]

The *Merge by Distance* node merges selected mesh vertices or point cloud points within a given distance,
merging surrounding geometry where necessary. This operation is similar to the [Merge by Distance](../../../meshes/editing/mesh/cleanup.xhtml#bpy-ops-mesh-remove-doubles)
operator or the [Weld Modifier](../../../modifiers/generate/weld.xhtml).
user: Explain Painting in complete detail according to the official Blender documentation.

assistant: # Painting

Sculpt Mode also allows painting your geometry via
[Color Attributes](../../../modeling/meshes/properties/object_data.xhtml#modeling-meshes-properties-object-data-color-attributes) such as Vertex Colors. This ensures that the most
common actions related to the sculpting workflow are contained in the same mode, to avoid unnecessary mode switching.

[image reference removed]

Other sculpt mode features such as face sets, masking and filters can also be used with painting tools.

The painting functionality in Sculpt Mode is limited to a
[Paint](../brushes/paint.xhtml)
and [Smear](../brushes/smear.xhtml) brush,
as well as a [Color Filter](../tools/color_filter.xhtml)
and [Mask by Color](../tools/mask_by_color.xhtml) tool.

Just like any other brush, `Shift` can be used to smooth.
In the case of painting brushes it will blur the colors within the brush radius instead.
user: How do I use Display in Blender? Include parameters, examples, warnings and best practices.

assistant: Fade
:   Opacity of the ghosts frames decrease the further away from the current frame.

Show Start Frame
:   Help working on loop animations showing the first keyframe/frame
    as ghost when you are on the last frame of your animation.

[image reference removed]

An example of Onion Skinning activated.
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

[[image reference removed]](../../../../_images/animation_armatures_posing_bone-constraints_introduction_tab.png)

The Bone Constraints Properties in Pose Mode,
with an Inverse Kinematics constraint added to the active bone.

As bones behave like objects in *Pose Mode*, they can also be constrained.
This is why the *Constraints* tab is shown in both *Object Mode* and *Edit Mode*.
This panel contains the constraints *of the active bone*
(its name is displayed at the top of the panel, in the *To Bone:…* static text field).

Constraining bones can be used to control their degree of freedom
in their pose transformations, using e.g. the *Limit* constraints.
You can also use constraints to make a bone track another object/bone
(inside the same object, or in another armature), etc.
And the [inverse kinematics feature](inverse_kinematics/introduction.html#bone-constraints-inverse-kinematics)
is also mainly available through the *IK Solver* constraint, which is specific to bones.

For example, a human elbow cannot rotate backward (unless the character has broken their arm),
nor to the sides, and its forward and roll rotations are limited in a given range.
(E.g. depending on the rest position of your elbow, it may be from (0 to 160) or from (-45 to 135).)

So you should apply a *Limit Rotation* constraint to the forearm bone
(as the elbow movement is the result of rotating the forearm bone around its root).

Using bones in constraints, either as owners or as targets, is discussed in detail
in the [constraints pages](../../../constraints/index.html).
user: Provide the full official documentation entry for F-Curves & Channels, preserving all code examples.

assistant: [F-Curves](../editors/graph_editor/fcurves/introduction.xhtml) are the fundamental
unit of animation in Blender, and are the main kind of animation data that
actions contain. Each F-Curve contains keyframes that define how a property
(such as the X location of an object) should change over time.

[image reference removed]

[Graph Editor](../editors/graph_editor/introduction.xhtml), displaying three
F-Curves for three different properties.

Blender’s animation editors (such as the dopesheet, graph editor, etc.) have a
**channel list** on their left side that display animated properties. For
actions, these channels correspond to the F-Curves that animate those
properties.

[image reference removed]

The [Dopesheet Editor’s](../editors/dope_sheet/introduction.xhtml) channel
list, with the animated channels of various bones grouped under their bone
names.

Channels also support a limited form of organization called “channel groups”.
For example, by default Blender creates a channel group for the channels of each
bone. There are a few features in Blender that rely on the groups, but mostly
they are just for your convenience.
user: Describe Chains of Bones from the Blender manual or Python API, including usage steps and snippets.

assistant: The bones inside an armature can be completely independent from each other
(i.e. the modification of one bone does not affect the others).
But this is not often a useful set up: To create a leg,
all bones “after” the thigh bone should move “with” it in a well-coordinated manner.
This is exactly what happens in armatures by parenting a bone to the next one in the limb,
you create a “chains of bones”. These chains can be ramified. For example,
five fingers attached to a single “hand” bone.

[image reference removed]

An armature with two chains of bones.

Bones are chained by linking the tip of the parent to the root of the child.
Root and tip can be *connected*, i.e. they are always exactly at the same point;
or they can be *free*, like in a standard parent-child object relationship.

A given bone can be the parent of several children,
and hence be part of several chains at the same time.

The bone at the beginning of a chain is called its *root bone*,
and the last bone of a chain is the *tip bone*
(do not confuse them with similar names of bones’ joints!).

Chains of bones are a particularly important topic in [posing](posing/index.xhtml)
(especially with the standard *forward* kinematics versus “automatic” *inverse* kinematics posing techniques).
You create/edit them in *Edit Mode*, but except in case of connected bones,
their relationships have no effect on bone transformations in this mode
(i.e. transforming a parent bone will not affect its children).

The easiest way to manage bones relationships is to use
the [Relations panel](bones/properties/relations.xhtml#bpy-types-editbone-parent) in the Bone tab.
user: Explain Example in complete detail according to the official Blender documentation.

assistant: Shadow Effect samples.

|  |  |  |
| --- | --- | --- |
| ../../_images/grease-pencil_visual-effects_shadow_simple.png   Simple Shadow. | ../../_images/grease-pencil_visual-effects_shadow_blur.png   Blurred Shadow. | ../../_images/grease-pencil_visual-effects_shadow_stretch.png   Stretched shadow with an empty as center of rotation. |
user: Describe Temporary Directory from the Blender manual or Python API, including usage steps and snippets.

assistant: The temporary directory is used to store various files at run-time
(including render layers, physics cache, copy-paste buffer and crash logs).

The temporary directory is selected based on the following priority:

- User Preference (see [File Paths](../editors/preferences/file_paths.html#prefs-file-paths)).
- Environment variables (`TEMP` on Windows, `TMP` & `TMP_DIR` on other platforms).
- The `/tmp/` directory.
user: Give a detailed overview of Intersect (Boolean): syntax, arguments, return values, common patterns.

assistant: # Intersect (Boolean)

Performs Boolean operations between the selected and unselected geometry.

[image reference removed]

Selecting a sphere and performing an Intersection, Union, and Difference
with a cube.

The [Adjust Last Operation](../../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel offers the following options:

Boolean Operation
:   Intersect:
    :   Only keep the volume that’s inside both the selected and the unselected geometry.

    Union:
    :   Remove the interior faces between the selected and the unselected geometry.

    Difference:
    :   Cut the selected geometry out of the unselected geometry, then remove the selected geometry.

Solver
:   Algorithm used to perform the Boolean operation.

    Float:
    :   Uses a simple solver which offers the good performance;
        however, this solver lacks support for overlapping geometry.

        Merge Threshold
        :   Tolerance for close faces to be considered touching.
            It may be useful to increase this when some intersections aren’t detected that should be and
            when extra geometry is being created because edges aren’t detected as overlapping.

    Exact:
    :   Uses a complex solver which offers the best results and has full
        support for overlapping geometry; however, this solver is much slower.

Swap
:   When using *Difference*, cut the unselected geometry out of the selected geometry instead
    of the other way around.

Self Intersection
:   Correctly handle self-intersection in the participating geometry, at the cost of performance.
user: Provide the full official documentation entry for Link & Append, preserving all code examples.

assistant: # Link & Append

These functions help you reuse objects, materials and other [data-blocks](../data_blocks.xhtml)
from another blend-file.
You can build libraries of common content and share them across multiple referencing files.
user: Explain bpy.utils submodule (bpy.utils.units) in complete detail according to the official Blender documentation.

assistant: # bpy.utils submodule (bpy.utils.units)

This module contains some data/methods regarding units handling.

bpy.utils.units.categories
:   Constant value bpy.utils.units.categories(NONE=’NONE’, LENGTH=’LENGTH’, AREA=’AREA’, VOLUME=’VOLUME’, MASS=’MASS’, ROTATION=’ROTATION’, TIME=’TIME’, TIME_ABSOLUTE=’TIME_ABSOLUTE’, VELOCITY=’VELOCITY’, ACCELERATION=’ACCELERATION’, CAMERA=’CAMERA’, POWER=’POWER’, TEMPERATURE=’TEMPERATURE’, WAVELENGTH=’WAVELENGTH’, COLOR_TEMPERATURE=’COLOR_TEMPERATURE’, FREQUENCY=’FREQUENCY’)

bpy.utils.units.systems
:   Constant value bpy.utils.units.systems(NONE=’NONE’, METRIC=’METRIC’, IMPERIAL=’IMPERIAL’)

bpy.utils.units.to_string(*unit_system*, *unit_category*, *value*, *\**, *precision=3*, *split_unit=False*, *compatible_unit=False*)
:   Convert a given input float value into a string with units.

    Parameters:
    :   - **unit_system** (*str*) – The unit system, from [`bpy.utils.units.systems`](#bpy.utils.units.systems "bpy.utils.units.systems").
        - **unit_category** (*str*) – The category of data we are converting (length, area, rotation, etc.),
          from [`bpy.utils.units.categories`](#bpy.utils.units.categories "bpy.utils.units.categories").
        - **value** (*float*) – The value to convert to a string.
        - **precision** (*int*) – Number of digits after the comma.
        - **split_unit** (*bool*) – Whether to use several units if needed (1m1cm), or always only one (1.01m).
        - **compatible_unit** (*bool*) – Whether to use keyboard-friendly units (1m2) or nicer UTF8 ones (1m²).

    Returns:
    :   The converted string.

    Return type:
    :   str

    Raises:
    :   **ValueError** – if conversion fails to generate a valid Python string.

bpy.utils.units.to_value(*unit_system*, *unit_category*, *str_input*, *\**, *str_ref_unit=None*)
:   Convert a given input string into a float value.

    Parameters:
    :   - **unit_system** (*str*) – The unit system, from [`bpy.utils.units.systems`](#bpy.utils.units.systems "bpy.utils.units.systems").
        - **unit_category** (*str*) – The category of data we are converting (length, area, rotation, etc.),
          from [`bpy.utils.units.categories`](#bpy.utils.units.categories "bpy.utils.units.categories").
        - **str_input** (*str*) – The string to convert to a float value.
        - **str_ref_unit** (*str* *|* *None*) – A reference string from which to extract a default unit, if none is found in `str_input`.

    Returns:
    :   The converted/interpreted value.

    Return type:
    :   float

    Raises:
    :   **ValueError** – if conversion fails to generate a valid Python float value.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`Mesh.uv_layer_clone`](bpy.types.Mesh.html#bpy.types.Mesh.uv_layer_clone "bpy.types.Mesh.uv_layer_clone") - [`Mesh.uv_layer_stencil`](bpy.types.Mesh.html#bpy.types.Mesh.uv_layer_stencil "bpy.types.Mesh.uv_layer_stencil") - [`Mesh.uv_layers`](bpy.types.Mesh.html#bpy.types.Mesh.uv_layers "bpy.types.Mesh.uv_layers") | - [`UVLoopLayers.active`](bpy.types.UVLoopLayers.html#bpy.types.UVLoopLayers.active "bpy.types.UVLoopLayers.active") - [`UVLoopLayers.new`](bpy.types.UVLoopLayers.html#bpy.types.UVLoopLayers.new "bpy.types.UVLoopLayers.new") - [`UVLoopLayers.remove`](bpy.types.UVLoopLayers.html#bpy.types.UVLoopLayers.remove "bpy.types.UVLoopLayers.remove") |
user: Provide the full official documentation entry for NodeSocketVectorTranslation(NodeSocketStandard), preserving all code examples.

assistant: # NodeSocketVectorTranslation(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.NodeSocketVectorTranslation(*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 3 items in [-inf, inf], default (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 Curve Tangent Node: syntax, arguments, return values, common patterns.

assistant: # Curve Tangent Node

[image reference removed]

The *Curve Tangent* node outputs the direction that a curve points in at each control point,
depending on the direction of the curve (which can be controlled with
the [Reverse Curve Node](../operations/reverse_curve.xhtml)). The output values are normalized vectors.
user: Show practical ways to work with X/Y/Z Global in a Blender add-on or script – include code.

assistant: These operations perform a non-interactive mirror along the global X, Y, or Z axis.

X Global
:   Mirrors the selection along the global X axis.

Y Global
:   Mirrors the selection along the global Y axis.

Z Global
:   Mirrors the selection along the global Z axis.
user: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

Compositing Nodes allow you to assemble and enhance an image (or movie). Using composition nodes,
you can glue two pieces of footage together and colorize the whole sequence all at once.
You can enhance the colors of a single image or an entire movie clip in a static manner or
in a dynamic way that changes over time (as the clip progresses). In this way,
you use composition nodes to both assemble video clips together and enhance them.

To process your image, you use nodes to import the image into Blender, change it,
optionally merge it with other images, and finally, save it.

[image reference removed]

An example of a composition.

[image reference removed]

An example of color correction.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

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

assistant: Image
:   Standard color input image.

Luminance Noise
:   Controls the amount of brightness variation (value noise) applied to the image.
    Higher values create stronger light and dark fluctuations, similar to high ISO noise.

Chroma Noise
:   Controls the amount of color noise added to the image.
    Higher values introduce visible color speckling, typical of low-light digital images.

Animated
:   When enabled, generates a new noise pattern on each frame, mimicking real sensor noise.
    When disabled, the noise remains static across frames.
user: Show practical ways to work with Exterior in a Blender add-on or script – include code.

assistant: # Exterior

Exterior forces are applied to the vertices (and nearly exclusively to the vertices)
of soft body objects. This is done using Newton’s Laws of Physics:

- If there is no force on a vertex, it stays either unmoved or moves with constant speed in a straight line.
- The acceleration of a vertex depends on its mass and the force.
  The heavier the mass of a vertex the slower the acceleration. The larger the force the greater the acceleration.
- For every action there is an equal and opposite reaction.

Well, this is done only in the range of computing accurateness,
there is always a little damping to avoid overshoot of the calculation.
user: What is Is Edge Manifold Node and how is it used in Blender Python scripting?

assistant: # Is Edge Manifold Node

[image reference removed]

The *Is Edge Manifold* node outputs a boolean value indicating whether each edge in a mesh
is *manifold*. A manifold edge is shared by exactly two faces and has consistent face normals,
meaning it is part of a continuous surface without gaps or branching edges.

This node is useful for detecting mesh topology issues or isolating boundary or non-manifold edges.
user: Give a detailed overview of GeometryNodeMeshIcoSphere(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeMeshIcoSphere(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.GeometryNodeMeshIcoSphere(*GeometryNode*)
:   Generate a spherical mesh that consists of equally sized triangles

    *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: Describe NodeSocketVectorXYZ(NodeSocketStandard) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeSocketVectorXYZ(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.NodeSocketVectorXYZ(*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 3 items in [-inf, inf], default (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: Show practical ways to work with Using Simulation to Shape/Sculpt a Mesh in a Blender add-on or script – include code.

assistant: You can *Apply* the Cloth Modifier at any point to freeze the mesh in
position at that frame. You can then re-enable the cloth,
setting the start and end frames from which to run the simulation forward.

Another example of aging is a flag.
Define the flag as a simple grid shape and pin the edge against the flagpole.
Simulate for 50 frames or so, and the flag will drop to its “rest” position.
Apply the *Cloth* Modifier.
If you want the flag to flap or otherwise move in the scene,
re-enable it for the frame range when it is in camera view.
user: What is ScriptDirectoryCollection(bpy_struct) and how is it used in Blender Python scripting?

assistant: # ScriptDirectoryCollection(bpy_struct)

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

*class* bpy.types.ScriptDirectoryCollection(*bpy_struct*)
:   *classmethod* new()
    :   Add a new Python script directory

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

    *classmethod* remove(*script_directory*)
    :   Remove a Python script directory

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # BlendDataAnnotations(bpy_struct)

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

*class* bpy.types.BlendDataAnnotations(*bpy_struct*)
:   Collection of annotations

    tag(*value*)
    :   tag

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

    new(*name*)
    :   Add a new annotation data-block to the main database

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

        Returns:
        :   New annotation data-block

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

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

        Parameters:
        :   - **annotation** ([`Annotation`](bpy.types.Annotation.html#bpy.types.Annotation "bpy.types.Annotation"), (never None)) – Grease Pencil to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this annotation before deleting it
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this annotation
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this annotation

    *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 File Substitution Tokens in a Blender add-on or script – include code.

assistant: Substitution tokens are special sequences of characters in a filename
that can be replaced with more meaningful and context aware information.
In this case, tokens are identified by being text wrapped in angle bracket characters.

This substitution is used while load loading or saving an image
to automatically identify the tile associated with a particular texture in the UDIM array.

The following tokens are supported:

- `<UDIM>`: A 4-digit notation calculated as `1001 + u-tile + v-tile * 10`.
- `<UVTILE>`: A notation defined as `u(u-tile + 1)_v(v-tile + 1)`.

Examples:

- `monster-basecolor.<UDIM>.png` will load/save files like `monster-basecolor.1021.png` etc.
- `monster-basecolor.<UVTILE>.png` will load/save files like `monster-basecolor.u1_v3.png` etc.
user: Give a detailed overview of Bpy.Types.Greasepenciltintmodifier: syntax, arguments, return values, common patterns.

assistant: Modifier.radius GreasePencilTintModifier.tint_mode GreasePencilTintModifier.tree_node_filter GreasePencilTintModifier.use_custom_curve GreasePencilTintModifier.use_layer_group_filter GreasePencilTintModifier.use_layer_pass_filter GreasePencilTintModifier.use_material_pass_filter GreasePencilTintModifier.use_weight_as_factor GreasePencilTintModifier.vertex_group_name GreasePencilTintModifier.bl_rna_get_subclass() GreasePencilTintModifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

Copy Location constraint.

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

Axis
:   The axes for which to copy location coordinates.

Invert
:   The axes for which invert the sign (so a coordinate of 10 becomes -10 and vice versa).

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

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

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Show practical ways to work with Maximize Area in a Blender add-on or script – include code.

assistant: Expands the editor area so it fills the whole window, while keeping the Topbar and Status Bar visible.
This is useful for focusing on a single editor (e.g. 3D Viewport, Shader Editor) without changing your workspace
layout.

In the 3D Viewport, maximizing the area temporarily hides:

- [Navigation Gizmos](../../editors/3dview/navigate/introduction.xhtml#navigation-gizmo)
- [Text Info](../../editors/3dview/display/overlays.xhtml#bpy-types-view3doverlay-show-text) overlay
- [Statistics](../../editors/3dview/display/overlays.xhtml#bpy-types-view3doverlay-show-stats) overlay

To return to normal size, use the shortcut again or click the *Back to Previous* button in the Topbar.
user: Explain ActionChannelbagGroups(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # ActionChannelbagGroups(bpy_struct)

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

*class* bpy.types.ActionChannelbagGroups(*bpy_struct*)
:   Collection of f-curve groups

    new(*name*)
    :   Create a new action group and add it to the action

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the action group

        Returns:
        :   Newly created action group

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

    remove(*action_group*)
    :   Remove action group

        Parameters:
        :   **action_group** ([`ActionGroup`](bpy.types.ActionGroup.html#bpy.types.ActionGroup "bpy.types.ActionGroup"), (never None)) – Action group to remove

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: In the first example, we overlay a grid pattern on top of two Suzanne heads after they have
been rendered. To achieve this, we enable the UV pass in the
[Property Editor](../../../editors/properties_editor.html)’s
View Layer ‣ Passes panel, use it to distort the grid image,
and combine the result with the rendered image using the Alpha Over Node.

[[image reference removed]](../../../_images/compositing_types_distort_map-uv_example-1.png)

Overlaying a grid texture.

In the next example, we do the same thing with the Blender logo, using a cryptomatte
to ensure it only gets applied to one of the cubes.

It’s here that the limitations of the Map UV node become apparent: the overlaid image is
really just “plastered on” and is not affected by the lighting and shadows in the scene.
At most, you can cheat a little by making the image translucent like in the previous example.

So, while this node can be handy for certain post-production effects or fixes,
it’s generally not a replacement for including the image during rendering.

[[image reference removed]](../../../_images/compositing_types_distort_map-uv_example-2.png)

Overlaying a logo.

The third example shows how an input image can be distorted using the Map UV node, where the image UV coordinates can
be extracted from the [Image Coordinates node](../input/image_coordinates.html#bpy-types-compositornodeimagecoordinates).

[[image reference removed]](../../../_images/compositing_types_distort_map-uv_example-3.png)

Procedural distortion.
user: Provide the full official documentation entry for Sculpting Brushes, preserving all code examples.

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: How do I use Set Shade Smooth Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Set Shade Smooth Node

[image reference removed]

The *Set Shade Smooth* node controls whether the mesh’s faces look smooth in the viewport and renders.
The smooth status of both edges and faces can be controlled, corresponding to the `sharp_edge` and
`sharp_face` attributes.
The input node for this data is the [Is Face Smooth Node](../read/is_face_smooth.html).
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Face Index
:   The index of the face for which to find the corners.

Weights
:   The weights of the corners in the geometry. Unlike the other inputs which follow
    the context domain, this one is always evaluated in the Face Corner domain.

    The corners are sorted by their associated weight in ascending order.
    Corners with the same weight are sorted by their index.

Sort Index
:   The 0-based index of the corner to select from the face’s sorted corners.
    If this value is outside the range of valid indices, it wraps around.
user: Describe Introduction from the Blender manual or Python API, including usage steps and snippets.

assistant: # Introduction

Modifiers are automatic operations that affect an object’s geometry in a non-destructive way.
With modifiers, you can perform many effects automatically that would otherwise be too tedious to do manually
(such as subdivision surfaces) and without affecting the base geometry of your object.

They work by changing how an object is displayed and rendered, but not the geometry which you can edit directly.
You can add several modifiers to a single object to form [The Modifier Stack](#the-modifier-stack)
and *Apply* a modifier if you wish to make its changes permanent.

They can be added to the active object using the [Add Modifier](../../scene_layout/object/editing/modifiers.xhtml#bpy-ops-object-modifier-add) operator,
the “Add Modifier” button at the top of Modifiers tab in the [Properties Editor](../../editors/properties_editor.xhtml),
or using `Shift`-`A` in the same tab.
New modifiers are always added at the bottom of the [stack](#modifier-stack) (i.e. will be applied last).

There are many built-in modifiers but Blender also allows users
to make their own modifiers through [Geometry Nodes](../geometry_nodes/index.xhtml).