PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain WeldModifier(Modifier) in complete detail according to the official Blender documentation.

assistant: # WeldModifier(Modifier)

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

*class* bpy.types.WeldModifier(*Modifier*)
:   Weld modifier

    invert_vertex_group
    :   Invert vertex group influence

        Type:
        :   boolean, default False

    loose_edges
    :   Collapse edges without faces, cloth sewing edges

        Type:
        :   boolean, default False

    merge_threshold
    :   Limit below which to merge vertices

        Type:
        :   float in [0, inf], default 0.001

    mode
    :   Mode defines the merge rule

        - `ALL`
          All – Full merge by distance.
        - `CONNECTED`
          Connected – Only merge along the edges.

        Type:
        :   enum in [`'ALL'`, `'CONNECTED'`], default `'ALL'`

    vertex_group
    :   Vertex group name for selecting the affected areas

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # BlendDataLineStyles(bpy_struct)

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

*class* bpy.types.BlendDataLineStyles(*bpy_struct*)
:   Collection of line styles

    tag(*value*)
    :   tag

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

    new(*name*)
    :   Add a new line style instance to the main database

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

        Returns:
        :   New line style data-block

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

    remove(*linestyle*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove a line style instance from the current blendfile

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Inherited Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`ShaderFx.name`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.name "bpy.types.ShaderFx.name") - [`ShaderFx.type`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.type "bpy.types.ShaderFx.type") - [`ShaderFx.show_viewport`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_viewport "bpy.types.ShaderFx.show_viewport") | - [`ShaderFx.show_render`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_render "bpy.types.ShaderFx.show_render") - [`ShaderFx.show_in_editmode`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_in_editmode "bpy.types.ShaderFx.show_in_editmode") - [`ShaderFx.show_expanded`](bpy.types.ShaderFx.html#bpy.types.ShaderFx.show_expanded "bpy.types.ShaderFx.show_expanded") |
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: See below for the result of using *Shear* on a number of different elements.

[image reference removed]

The effects of a Shear transform with different Pivot Points.

The three frames of the image above show the effects of shearing
on the selected vertices when the pivot point is altered.
In middle frame, the [Pivot Point](../../../../../editors/3dview/controls/pivot_point/index.html)
is set to *Median Point* and the mouse was moved to the left during the transform.
In right frame, the *Pivot Point* is set to the 3D cursor which is located above the mesh.
When the mouse is moved to the left during a *Shear* transform,
the selected vertices are moved to the right as they are below the horizontal axis.

[image reference removed]

The effects of a Shear transform on objects with different Pivot Points.
user: How do I use Common Options in Blender? Include parameters, examples, warnings and best practices.

assistant: These options can be specified in the [Adjust Last Operation](../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel,
which appears when the object is created.
Options included in more than one primitive are:

Generate UVs
:   Generates a default UV unwrapping of new geometry.
    This will be defined in the first UV layer (which will get added if needed).

Align to View, Location, Rotation
:   See [Common Object Options](../../scene_layout/object/types.xhtml#object-common-options).
user: Explain Multi-Object Editing in complete detail according to the official Blender documentation.

assistant: Edit Mode and Pose Mode let you work with multiple objects even more
easily than described above, as they can have multiple objects in the mode
at the same time.

There are two ways of accomplishing this:

- If you’re not yet in the mode, you can simply select all the objects
  and enter it.
- If you’re already in the mode, you can bring other objects into it
  by clicking `Ctrl`-`LMB` on the dot in the
  [Outliner](../outliner/introduction.xhtml).
  Removing objects from the mode works in the same way.

Some points of note:

- The [Properties Editor](../properties_editor.xhtml) editor will only ever show the details
  (shape keys, UV maps…) of the active object, not of all the selected ones.
- Selecting any element from an object will make it the active one.
- There are limits to the edits you can make.
  For example, you can’t create an edge that connects vertices from
  different objects.
user: Describe Outline from the Blender manual or Python API, including usage steps and snippets.

assistant: The *Outline* operator converts selected Grease Pencil strokes into closed perimeter shapes.
It creates new strokes around the outer boundary of the original stroke,
effectively generating a filled outline with adjustable thickness.

View
:   Defines the projection method used to generate the outline:

    View:
    :   Use the current viewport perspective as the projection plane.

    Front:
    :   Use the X-Z axes as the projection plane (front view).

    Side:
    :   Use the Y-Z axes as the projection plane (side view).

    Top:
    :   Use the X-Y axes as the projection plane (top view).

    Camera:
    :   Use the active camera’s perspective as the projection plane.

Radius
:   Sets the thickness of the outline on both sides of the original stroke.
    Higher values result in a wider perimeter.

Offset Factor
:   Scales the stroke outline inward or outward.
    - Positive values push the perimeter outward.
    - Negative values pull it inward.
    - A value of 0 centers the perimeter on the original stroke.

Corner Subdivisions
:   Number of subdivisions used to smooth corners at stroke endpoints and joints.
    Higher values result in smoother corners but increase stroke complexity.

|  |  |
| --- | --- |
| ../../../_images/grease-pencil_modes_edit_stroke-menu_outline-1.png   Original stroke. | ../../../_images/grease-pencil_modes_edit_stroke-menu_outline-2.png   Stroke after applying the *Outline* operator. |
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Grid
:   The input signed distance field to be smoothed.

Width
:   The radius of the smoothing kernel in voxels.
    Larger values result in a broader smoothing effect, producing softer,
    less detailed surfaces. Smaller values restrict smoothing to immediate
    neighbors, retaining more fine detail.

Iterations
:   The number of times the mean filter is applied.
    Each iteration increases the smoothness of the surface.
    Multiple passes can approximate a Gaussian-like blur effect.
user: Describe Separate from the Blender manual or Python API, including usage steps and snippets.

assistant: Creates a new point cloud object from the currently selected points.

This is useful for breaking a larger scan or dataset into manageable segments
or organizing different regions of points into separate objects.
user: How do I use Set Active Keying Set in Blender? Include parameters, examples, warnings and best practices.

assistant: There are several ways to designate the active keying set:

- Press `Shift`-`K` in the 3D Viewport.
- Select a keying set in the [Keying Set](#bpy-types-keyingsets) panel.
- Select a keying set in the [Keying popover](../animation_editors.xhtml#animation-editors-keying) in the Timeline header,
user: Explain Example in complete detail according to the official Blender documentation.

assistant: Tint uniform color sample.

|  |  |  |
| --- | --- | --- |
| ../../../_images/grease-pencil_modifiers_color_tint_factor-0.png   Strength: 0 (original color). | ../../../_images/grease-pencil_modifiers_color_tint_factor-05.png   Strength: 0.5. | ../../../_images/grease-pencil_modifiers_color_tint_factor-1.png   Strength: 1.0 (fully tinted). |

Tint gradient color sample.

|  |  |  |
| --- | --- | --- |
| ../../../_images/grease-pencil_modifiers_color_tint_gradient-01.png   Radius: 1, Strength: 1. | ../../../_images/grease-pencil_modifiers_color_tint_gradient-02.png   Radius: 5, Strength: 1. | ../../../_images/grease-pencil_modifiers_color_tint_gradient-03.png   Radius: 10, Strength: 1. |
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Collection
:   Collection to get the properties from.

Separate Children
:   Output each child of the collection as a separate instance. The list of instances will be sorted
    alphabetically with the objects and child collections sorted together. This can be used with
    the *Pick Instance* option in the [Instance on Points Node](../../instances/instance_on_points.html) to
    choose between collection children at each point.

Reset Children
:   Remove the transform of each of the collection’s children when converting them to instances.
    This is useful in order to keep child objects visually separate in the viewport,
    while keeping every instance located directly at the location of the point it was added for.
user: Describe External Links from the Blender manual or Python API, including usage steps and snippets.

assistant: - [Skin Modifier Development at Blender Nation](https://www.blendernation.com/2011/03/11/skin-modifier-development/) –
  An early demonstration of the Skin Modifier by Nicholas Bishop (March 2011).
- Ji, Zhongping; Liu, Ligang; Wang, Yigang (2010).
  B-Mesh: A Fast Modeling System for Base Meshes of 3D Articulated Shapes,
  Computer Graphics Forum 29(7), pp. 2169-2178. – The work this modifier is based on
  ([DOI 10.1111/j.1467-8659.2010.01805.x](https://doi.org/10.1111/j.1467-8659.2010.01805.x)).
- [Related thread on Blender artists](https://blenderartists.org/t/499364).
user: Provide the full official documentation entry for StripElement(bpy_struct), preserving all code examples.

assistant: # StripElement(bpy_struct)

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

*class* bpy.types.StripElement(*bpy_struct*)
:   Sequence strip data for a single frame

    filename
    :   Name of the source file

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

    orig_fps
    :   Original frames per second

        Type:
        :   float in [-inf, inf], default 0.0, (readonly)

    orig_height
    :   Original image height

        Type:
        :   int in [-inf, inf], default 0, (readonly)

    orig_width
    :   Original image width

        Type:
        :   int in [-inf, inf], default 0, (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Mesh Analysis: syntax, arguments, return values, common patterns.

assistant: # Mesh Analysis

Mesh analysis is useful for displaying attributes of the mesh,
that may impact certain use cases.

The mesh analysis works in *Edit Mode* and *Solid* Viewport shading.
It shows areas with a high value in red, and areas with a low value in blue.
Geometry outside the range is displayed gray.

Currently the different modes target 3D printing as their primary use.
user: Describe Operator Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Most operators have properties that can be adjusted to refine their result.
First run the operator (which will use its default settings),
then adjust the properties in the [Adjust Last Operation](undo_redo.html#bpy-ops-screen-redo-last) region.
user: How do I use Flip in Blender? Include parameters, examples, warnings and best practices.

assistant: This will reverse the normals direction of all selected faces.
Note that this allows you to precisely control the direction
(**not** the orientation, which is always perpendicular to the face) of your normals,
as only the selected faces are flipped.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Is Strand
:   Outputs 1 when the shader is acting on a strand, otherwise 0.

Intercept
:   The point along the strand where the ray hits the strand (1 at the tip and 0 at the root).

Length
:   The total measurement from the root to the tip of the strand,
    interpreted as a grayscale value from 0 to infinity.

Thickness
:   The thickness of the strand at the point where the ray hits the strand.

Tangent Normal
:   Tangent normal of the strand.

Random
:   A random per-curve value in the range from 0 to 1.
    It can for example be used in combination with a color ramp, to randomize the curve’s color.
user: How do I use GeometryNodeCurveSpiral(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeCurveSpiral(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.GeometryNodeCurveSpiral(*GeometryNode*)
:   Generate a poly spline in a spiral shape

    *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: How do I use GPU Rendering in Blender? Include parameters, examples, warnings and best practices.

assistant: # GPU Rendering

GPU rendering makes it possible to use your
graphics card for rendering, instead of the CPU. This can speed up rendering
because modern GPUs are designed to do quite a lot of number crunching.
On the other hand, they also have some limitations in rendering complex scenes, due to more limited memory,
and issues with interactivity when using the same graphics card for display and rendering.

To enable GPU rendering:

1. Select either *CUDA*, *OptiX*, *HIP*, *oneAPI*, or *Metal*
   in the [Cycles Render Devices](../../editors/preferences/system.xhtml#editors-preferences-cycles) user preference.
2. Enable the available devices for the chosen backend.
3. Configure each scene to use the *GPU Compute* [Device](render_settings/index.xhtml#bpy-types-cyclesrendersettings-device).
user: What is GeometryNodeSetID(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeSetID(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.GeometryNodeSetID(*GeometryNode*)
:   Set the id attribute on the input geometry, mainly used internally for randomizing

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

assistant: Another common cause of problems for printing are intersections between surfaces,
where the inside/outside of a model cannot be reliably detected.

Unlike other display modes, intersections have no variance and are either on or off.

[image reference removed]

Intersecting faces.
user: Explain Source in complete detail according to the official Blender documentation.

assistant: The Source panel shows (and lets you change) the file which the strip points to,
as well as how this file should be displayed.

Directory
:   The folder containing the source file for the strip.

Filename
:   The name of the source file.
    Note that file names are limited to 256 characters.

Color Space
:   The color space of the source file.

    The list of color spaces depends on the active [OCIO config](../../../../render/color_management/opencolorio.html#ocio-config).
    The default supported color spaces are described in detail here:
    [Default OpenColorIO Configuration](../../../../render/color_management/color_spaces.html#ocio-config-default-color-spaces)

Alpha Mode
:   If the source file has an Alpha (transparency) channel, you can choose between
    [Straight Alpha](../../../../glossary/index.html#term-Straight-Alpha) and [Premultiplied Alpha](../../../../glossary/index.html#term-Premultiplied-Alpha).

Stream Index Movie Strip
:   The video stream to use, in case there are multiple.

Deinterlace
:   Applies deinterlacing to analog video.

Source Information
:   Displays information about the strip’s media.

    Resolution
    :   Resolution of the active strip’s image output.

    FPS Movie Strip
    :   The frame rate encoded into the video file.
        If this value does not match the scene’s [Frame Rate](../../../../render/output/properties/format.html#bpy-types-rendersettings-fps),
        the perceived speed of the media will be wrong unless the speed is
        [changed](../../../../video_editing/edit/montage/strips/effects/speed_control.html#video-editing-change-fps) to account for the difference.

### Options for Image Strips

Directory
:   The directory that contains the source file(s).

Filename
:   The name of the source file. For image sequences, this will be different for each frame.

Change Data/Files
:   Opens a File Browser to let you select a new set of images (as an alternative to modifying
    the above textboxes). Same as Strip ‣ Inputs ‣ Change Paths/Files.

### Options for Sound Strips

Sound
:   [Data-block menu](../../../../interface/controls/templates/data_block.html#ui-data-block) to select a sound.

File Path
:   Path to the file used by the selected sound [data-block](../../../../interface/controls/templates/data_block.html#ui-data-block).

Pack
:   [Pack](../../../../files/blend/packed_data.html) the sound into the blend-file.

Caching
:   Sound file is decoded and loaded into the RAM.

Source Information
:   Displays information about the strip’s media.

    Sample Rate
    :   The number of samples per second the audio is encoded at.

    Channels
    :   The number of audio channels encoded into the audio stream.
user: Describe Single Image from the Blender manual or Python API, including usage steps and snippets.

assistant: When you add a single still image (`*.jpg`, `*.png`, etc.),
by default, Blender will create a 25 frame long strip which renders the image throughout the strip’s range in the timeline.
This length can be adjusted by adding images through the “Add Image Strip” operator and changing the property in the sidebar.
user: Give a detailed overview of Simulation Zone: syntax, arguments, return values, common patterns.

assistant: # Simulation Zone

Simulation zones allow the result of one frame to influence the next one.
That way even a set of simple rules can lead to complex results, with the passing of time.
The most common type of them is physics simulation, with specific solvers for physical phenomena.

[image reference removed]

Initial simulation nodes and simulation zone.

When adding a simulation, two nodes are added, defining between them a “Simulation Zone”.

The inputs that are connected to the Simulation Input node are evaluated only once,
at the beginning of the simulation, passed to the next simulation state and eventually outputted.
Other nodes can be linked inside the simulation region from the outside.
Those are re-evaluated every step based on their value at the given frame.

It is not possible to have any link going towards outside.
The result of the simulation can only be accessed via the Simulation Output node.
This also allows sub-frame interpolation for motion blur.
user: Describe Show/Hide from the Blender manual or Python API, including usage steps and snippets.

assistant: Hides the selected or unselected control points, or unhides all hidden
control points.

By default, unhiding control points adds them to the selection.
To prevent this, uncheck the *Select* option in the [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.
user: How do I use Inherited Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`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: Describe ParticleHairKey(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ParticleHairKey(bpy_struct)

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

*class* bpy.types.ParticleHairKey(*bpy_struct*)
:   Particle key for hair particle system

    co
    :   Location of the hair key in object space

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

    co_local
    :   Location of the hair key in its local coordinate system, relative to the emitting face

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

    time
    :   Relative time of key over hair length

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

    weight
    :   Weight for cloth simulation

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

    co_object(*object*, *modifier*, *particle*)
    :   Obtain hairkey location with particle and modifier data

        Parameters:
        :   - **object** ([`Object`](bpy.types.Object.html#bpy.types.Object "bpy.types.Object"), (never None)) – Object
            - **modifier** ([`ParticleSystemModifier`](bpy.types.ParticleSystemModifier.html#bpy.types.ParticleSystemModifier "bpy.types.ParticleSystemModifier"), (never None)) – Particle modifier
            - **particle** ([`Particle`](bpy.types.Particle.html#bpy.types.Particle "bpy.types.Particle"), (never None)) – hair particle

        Returns:
        :   Co, Exported hairkey location

        Return type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf]

    co_object_set(*object*, *modifier*, *particle*, *co*)
    :   Set hairkey location with particle and modifier data

        Parameters:
        :   - **object** ([`Object`](bpy.types.Object.html#bpy.types.Object "bpy.types.Object"), (never None)) – Object
            - **modifier** ([`ParticleSystemModifier`](bpy.types.ParticleSystemModifier.html#bpy.types.ParticleSystemModifier "bpy.types.ParticleSystemModifier"), (never None)) – Particle modifier
            - **particle** ([`Particle`](bpy.types.Particle.html#bpy.types.Particle "bpy.types.Particle"), (never None)) – hair particle
            - **co** ([`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf]) – Co, Specified hairkey location

    *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 Growing and how is it used in Blender Python scripting?

assistant: The first step is to create the hair, specifying the amount of hair strands and their lengths.

The complete path of the particles is calculated in advance.
So everything a particle does a hair may do also.
A hair is as long as the particle path would be for a particle with a lifetime of 100 frames.
Instead of rendering every frame of the particle animation point by point there are calculated
control points with an interpolation, the segments.
user: What is Spline Types and how is it used in Blender Python scripting?

assistant: ### Poly

Poly splines are the simplest type, with no interpolation between control points.
They are used when [converting meshes to curves](../../scene_layout/object/editing/convert.html#bpy-ops-object-convert)
for accurate representation of the original mesh.
While Poly splines are precise, [Bézier](#bezier) or [NURBS](#nurbs) splines are generally preferred for smooth curves.

### Bézier

Bézier splines use control points and handles to define their shape.
A curve segment exists between two control points, with the handles controlling the curvature.

In the illustration below, the control points are at the center of the pink lines, while the handles extend outward.
The arrows represent the curve normals, indicating direction and tilt.

[image reference removed]

Bézier Curve in Edit Mode.

#### Handle Types

Bézier curves support four handle types, which can be changed with `V`:

[image reference removed]

Bézier Curve Handle Types.

Automatic:
:   Automatically adjusts handle length and direction for the smoothest curve.
    Displayed as yellow handles. Converts to *Aligned* when moved.

Vector:
:   Handles point directly toward adjacent control points, enabling straight lines or sharp corners.
    Displayed as green handles. Converts to *Free* when moved.

Aligned:
:   Handles remain on a straight line, ensuring smooth, continuous curves.
    Displayed as purple handles.

Free:
:   Handles move independently, allowing for asymmetric curves.
    Displayed as black handles.

### NURBS

NURBS (Non-Uniform Rational B-Splines) are mathematically precise splines, offering exact shapes.
Unlike Bézier curves, which approximate shapes (e.g., a Bézier circle approximates a perfect circle),
NURBS can represent exact geometry.

For more information, refer to the [Wikipedia page](https://en.wikipedia.org/wiki/NURBS).
user: What is IMAGE_UL_render_slots(UIList) and how is it used in Blender Python scripting?

assistant: # IMAGE_UL_render_slots(UIList)

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

*class* bpy.types.IMAGE_UL_render_slots(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *_icon*, *_active_data*, *_active_propname*, *_index*)

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

assistant: # UV Unwrap Node

[image reference removed]

The *UV Unwrap Node* generates a UV map islands based on a selection of seam edges.
The node implicitly performs a [Pack Islands](pack_uv_islands.xhtml)
operation upon completion, because the results may not be generally useful otherwise.
user: Describe Notes from the Blender manual or Python API, including usage steps and snippets.

assistant: - Blender internally works in *linear color space*; conversions from sRGB or other spaces happen automatically.
- The color picker displays the color as it appears in the current view transform, but the stored value remains linear.
- For consistent results across renders and display devices, see
  [Color Management](../../../render/color_management/index.xhtml).
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Segment Coordinates
:   Segment coordinates for texture mapping within each radial segment.

Segment ID
:   Unique ID for every radial segment startiing at 0 and increasing counterclockwise by 1 for every for each segment.

Segment Width
:   Relative width of each radial segment. May be used to scale textures to fit into each segment.

Segment Rotation
:   Counterclockwise rotation of each segment coordinate system. May be used to align the rotation of the textures of each segment.
user: Give a detailed overview of Hooks: syntax, arguments, return values, common patterns.

assistant: # Hooks

Adds a [Hook Modifier](../../../modifiers/deform/hooks.xhtml)
(using either a new empty, or the current selected object) linked to the selection.
Note that even if it appears in the history menu,
this action cannot be undone in *Edit Mode* – because it involves other objects…

When the current object has no hooks associated, only the first two options will appear on the menu.

Hook to New Object
:   Creates a new Hook Modifier for the active object and assigns it to the selected vertices;
    it also creates an empty at the center of those vertices, which are hooked to it.

Hook to Selected Object
:   Does the same as *Hook to New Object*, but instead of hooking the vertices to a new empty,
    it hooks them to the selected object (if it exists).
    There should be only one selected object (besides the mesh being edited).

Hook to Selected Object Bone
:   Does the same as *Hook to New Object*,
    but it sets the last selected bone in the also selected armature as a target.

Assign to Hook
:   The selected vertices are assigned to the chosen hook. For that to happen,
    a list of the hooks associated to the object is displayed.
    All the unselected vertices are removed from it (if they were assigned to that particular hook).
    One vertex can be assigned to more than one hook.

Remove Hook
:   Removes the chosen hook (from the displayed list) from the object.
    Which means that the specific Hook Modifier is removed from its modifier stack.

Select Hook
:   Selects all vertices assigned to the chosen hook (from the hook list).

Reset Hook
:   It’s equivalent to the *Reset* button of the specific Hook Modifier (chosen from the hook list).

Recenter Hook
:   It’s equivalent to the *Recenter* button of the specific Hook Modifier (chosen from the hook list).
user: What is Brush Types and how is it used in Blender Python scripting?

assistant: See [Brush Type](../brush/brush_settings.xhtml#sculpt-tool-settings-brush-type).

Available brush types are listed here, together with brushes from the
*Essentials* asset library using them.

Draw
:   Brushes: Paint

    Paints a specified weight over the object.

    Blend
    :   The brush [Blend Modes](../../glossary/index.xhtml#term-Blend-Modes) defines in which way the weight value is
        applied to the vertex group while painting.

        Mix
        :   In this Blending mode the Weight value defines the *target weight*
            that will eventually be reached when you paint long enough on the same
            location of the mesh. And the strength determines how many strokes
            you need to place at the target weight. Note that for strength = 1.0
            the target weight is painted immediately and for Weight = 0.0 the brush just does nothing.

        Add
        :   In this Blending mode the specified weight value is *added* to the vertex weights.
            The strength determines which fraction of the weight gets added per stroke.
            However, the brush will not paint weight values above 1.0.

        Subtract
        :   In this Blending mode the specified weight value is *subtracted* from the vertex weights.
            The strength determines which fraction of the weight gets removed per stroke.
            However, the brush will not paint weight values below 0.0.

        Lighten
        :   In this Blending mode the specified weight value is interpreted as the target weight.
            Very similar to the Mix Blending mode, but only weights below the target weight are affected.
            Weights above the target weight remain unchanged.

        Darken
        :   This Blending mode is very similar to the Lighten Blending mode.
            But only weights above the target weight are affected.
            Weights below the target weight remain unchanged.

        Multiply
        :   Multiplies the vertex weights with the specified weight value.
            This is somewhat like subtract, but the amount of removed weight is now
            dependent on the Weight value itself.

        Blur
        :   Smooths out the weighting of adjacent vertices. In this mode the Weight
            Value is ignored. The strength defines how much the smoothing is applied.

Blur
:   Brushes: Blur

    Smooths out the weighting of adjacent vertices. In this mode the Weight
    Value is ignored. The strength defines how much the smoothing is applied.

Average
:   Brushes: Average

    Smooths weights by painting the average resulting weight from all weights under the brush.

Smear
:   Brushes: Smear

    Smudges weights by grabbing the weights under the brush and “dragging” them.
    This can be imagined as a finger painting tool.
user: What is Accessing Mesh Operators and how is it used in Blender Python scripting?

assistant: The mesh editing operations are found in various places, and available through shortcuts as well.

### Menus

These menus are located in the header.
Some of the menus can be accessed with shortcuts:

- `Ctrl`-`F` brings up the Face operators menu
- `Ctrl`-`E` brings up the Edge operators menu
- `Ctrl`-`V` brings up the Vertex operators menu
user: Describe CompositorNodeCustomGroup(CompositorNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CompositorNodeCustomGroup(CompositorNode)

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

*class* bpy.types.CompositorNodeCustomGroup(*CompositorNode*)
:   Custom Compositor Group Node for Python nodes

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe TextureNodeCurveRGB(TextureNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # TextureNodeCurveRGB(TextureNode)

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

*class* bpy.types.TextureNodeCurveRGB(*TextureNode*)
:   mapping
    :   Type:
        :   [`CurveMapping`](bpy.types.CurveMapping.html#bpy.types.CurveMapping "bpy.types.CurveMapping"), (readonly)

    *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 Point Cloud and how is it used in Blender Python scripting?

assistant: # Point Cloud

[Point clouds](../../glossary/index.xhtml#term-Point-Cloud) are a type of object used to represent
large numbers of individual points in 3D space.
They are particularly useful for visualizing 3D scan data, particle simulations,
or sparse datasets where a surface mesh is unnecessary or impractical.

Each point in a point cloud can store data using *Attributes*
that define properties such as position, color, and more.
Future updates may expand support to include simulation systems like particles.

[image reference removed]

Example of a monkey object represented as a point cloud.
user: Describe ArmatureBones(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ArmatureBones(bpy_struct)

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

*class* bpy.types.ArmatureBones(*bpy_struct*)
:   Collection of armature bones

    active
    :   Armature’s active bone

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

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

assistant: Target Object
:   Determines if the image empty is kept or replaced.

    New Object: Creates a new Grease Pencil object and keeps the image empty
    Selected Object: Replaces the image empty with the Grease Pencil object.

Radius
:   The thickness of the generated Grease Pencil strokes.

Color Threshold
:   Determine the [Luminance](../../../glossary/index.xhtml#term-Luminance) threshold above which strokes are generated.

Turn Policy
:   Determines how to resolve ambiguities during decomposition of an image into paths.

    Black:
    :   Prioritizes to connect black (foreground) components.

    White:
    :   Prioritizes to connect white (background) components.

    Left:
    :   Always take a left turn.

    Right:
    :   Always take a right turn.

    Minority:
    :   Prioritizes to connect the color (black or white) that occurs
        least frequently in the local neighborhood of the current position.

    Majority:
    :   Prioritizes to connect the color (black or white) that occurs
        most frequently in the local neighborhood of the current position.

    Random:
    :   Choose pseudo-randomly.

Mode
:   Determines if the image being traced is a single image or image sequence.

    Single:
    :   The image empty is a single image or the current frame of an image sequence.

    Sequence:
    :   The image empty is an [Image Sequence](../../../editors/image/image_settings.xhtml#image-sequence).

Start at Current Frame
:   When enabled, start the tracing process at the current image frame.

Trace Frame
:   Used to trace only one frame of the image sequence, set to zero to trace all.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Vector
:   Vector to be rotated.

Center
:   Point to rotate around.

Axis
:   Axis to rotate around.

Angle
:   Angle to rotate the input vector by.

Rotation
:   When *Type* is set to *Euler*, rotate the input vector
    by these angles around the X, Y, then Z axes in that order.
user: Explain Enable Output Node in complete detail according to the official Blender documentation.

assistant: # Enable Output Node

[image reference removed]

The *Enable Output* node toggles the visibility and value
of a socket for a [Node Group](../../groups.xhtml) outputs.
It can be used to conditionally show or hide outputs from a node group depending on an input value or condition.
user: Provide the full official documentation entry for SCENE_UL_gltf2_filter_action(UIList), preserving all code examples.

assistant: # SCENE_UL_gltf2_filter_action(UIList)

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

*class* bpy.types.SCENE_UL_gltf2_filter_action(*UIList*)
:   draw_item(*context*, *layout*, *data*, *item*, *icon*, *active_data*, *active_propname*, *index*)

    *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