PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Cloth on Armature and how is it used in Blender Python scripting?

assistant: Clothing can be simulated and pinned to an armature.
For example, a character could have a baggy tunic pinned to the character’s waist with a belt.

The typical workflow for pinning:

1. Set the armature to its bind pose.
2. Model clothing that encloses but does not penetrate the character’s mesh.
3. Parent the clothing objects to the armature. The armature will now have several child meshes bound to it.
4. Create a new vertex group on each cloth object for its pinned vertices.
5. Add vertices to be pinned to this vertex group and give these vertices nonzero weights
   (you probably want weight = 1).
   For example the belt area of the tunic would be in the vertex group and have weight one.
6. Designate the clothing objects as “cloth” in the Physics tab of the Properties.
   Make sure the Cloth Modifier is below the Armature Modifier in the modifier stack.
7. In the cloth Shape panel select the vertex group.
8. Add [collision physics](../collision.xhtml) to the character’s mesh.
9. The clothing is now ready; non-pinned vertices will be under control of the Cloth modifier.
   Pinned vertices will be under control of the Armature modifier.

[Regression blend-file](https://archive.blender.org/wiki/2015/index.php/File:Cloth-regression-armature.blend).
user: Show practical ways to work with Curve Root in a Blender add-on or script – include code.

assistant: # Curve Root

The *Curve Root* node outputs information related to the root point of each curve.
It is commonly used in hair grooming and procedural setups to anchor deformations,
apply transformations relative to the curve base, or isolate operations affecting
only the roots.
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: The curves are useful to see if particular trackers are moving differently than the average.
A line that spikes from the rest of the curve usually means a tracking error.

You can manually edit the curve by selecting a point in the curve and dragging it or deleting,
that will affect the corresponding tracker on that particular frame.

Lock to Selection `L`
:   Locks the view to selected markers during playback.
user: Explain UserExtensionRepoCollection(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # UserExtensionRepoCollection(bpy_struct)

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

*class* bpy.types.UserExtensionRepoCollection(*bpy_struct*)
:   Collection of user extension repositories

    *classmethod* new(*\**, *name=''*, *module=''*, *custom_directory=''*, *remote_url=''*, *source='USER'*)
    :   Add a new repository

        Parameters:
        :   - **name** (*string**,* *(**optional**,* *never None**)*) – Name
            - **module** (*string**,* *(**optional**,* *never None**)*) – Module
            - **custom_directory** (*string**,* *(**optional**,* *never None**)*) – Custom Directory
            - **remote_url** (*string**,* *(**optional**,* *never None**)*) – Remote URL
            - **source** (enum in [`'USER'`, `'SYSTEM'`], (optional)) –

              Source, How the repository is managed

              - `USER`
                User – Repository managed by the user, stored in user directories.
              - `SYSTEM`
                System – Read-only repository provided by the system.

        Returns:
        :   Newly added repository

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

    *classmethod* remove(*repo*)
    :   Remove repos

        Parameters:
        :   **repo** ([`UserExtensionRepo`](bpy.types.UserExtensionRepo.html#bpy.types.UserExtensionRepo "bpy.types.UserExtensionRepo"), (never None)) – Repository 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: Describe NodeTreeInterfaceSocketVectorVelocity4D(NodeTreeInterfaceSocket) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeTreeInterfaceSocketVectorVelocity4D(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketVectorVelocity4D(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

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

assistant: # Frame Node

The *Frame* node is used to organize and group other nodes within the editor.
It helps manage complex node trees by visually grouping related nodes together.

Frames are particularly useful when the setup is too large to view easily at once,
or when you want to separate logical sections of a node tree without creating a reusable Node Group.

[image reference removed]

Example of a Frame node used to organize nodes.
user: Explain Sidebar Region in complete detail according to the official Blender documentation.

assistant: ### View Tab

[image reference removed]

View Tab.

Show Cursor
:   Toggles the visibility of the [2D Cursor](#graph-editor-2d-cursor)’s horizontal line.

Cursor X, Y
:   Shows, and lets you change, the X coordinate (current frame) and Y coordinate (value) of the 2D Cursor.

Cursor to Selection
:   Places the 2D Cursor at the average time and value of the selected keyframes.

Cursor Value to Selection
:   Places the 2D Cursor at the average value of the selected keyframes, leaving its time unchanged.

### F-Curve Tab

See [F-Curve Properties](fcurves/properties.xhtml).

### Modifiers Tab

See [F-Curve Modifiers](fcurves/modifiers.xhtml).
user: Describe Symmetrize from the Blender manual or Python API, including usage steps and snippets.

assistant: # Symmetrize

The *Symmetrize* tool is a quick way to make a mesh symmetrical.
*Symmetrize* works by cutting the mesh at the pivot point of the object,
and mirroring over the geometry in the specified axis, and merges the two halves together
(if they are connected). Also the mesh data is copied from one side to the other:
e.g. UVs, colors attributes, vertex weights.

Direction
:   Specify the axis and direction of the effect. Can be any of the three axes,
    and either positive to negative, or negative to positive.

Threshold
:   The vertices in this range will be snapped to the plane of symmetry.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_symmetrize_example-1.png   Mesh before Symmetrize. | ../../../../_images/modeling_meshes_editing_mesh_symmetrize_example-2.png   Mesh after Symmetrize. |
user: Show practical ways to work with PARTICLE_UL_particle_systems(UIList) in a Blender add-on or script – include code.

assistant: # PARTICLE_UL_particle_systems(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.PARTICLE_UL_particle_systems(*UIList*)
:   draw_item(*_context*, *layout*, *data*, *item*, *icon*, *_active_data*, *_active_propname*, *_index*, *_flt_flag*)

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

assistant: # ThemePreferences(bpy_struct)

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

*class* bpy.types.ThemePreferences(*bpy_struct*)
:   Theme settings for the Blender Preferences

    space
    :   Settings for space

        Type:
        :   [`ThemeSpaceGeneric`](bpy.types.ThemeSpaceGeneric.html#bpy.types.ThemeSpaceGeneric "bpy.types.ThemeSpaceGeneric"), (readonly, 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: Give a detailed overview of Holdout: syntax, arguments, return values, common patterns.

assistant: # Holdout

[image reference removed]

The *Holdout* shader node is used to create a “hole” in the image with zero alpha
transparency, which is useful for compositing (see [Alpha Channel](../../../glossary/index.xhtml#term-Alpha-Channel)).
user: Explain V in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [**Value**](glossary/index.xhtml#term-Value) - [Version Number Guidelines](advanced/extensions/version_number_guidelines.xhtml#index-0) - [**Vertex**](glossary/index.xhtml#term-Vertex) - [**Vertex Group**](glossary/index.xhtml#term-Vertex-Group) - [**Vertices**](glossary/index.xhtml#term-Vertices) - [Video Sequencer Modifiers](video_editing/edit/montage/strip_modifiers.xhtml#index-1)   - [Brightness/Contrast Modifier](video_editing/edit/montage/strip_modifiers.xhtml#index-2)   - [Color Balance Modifier](video_editing/edit/montage/strip_modifiers.xhtml#index-3)   - [Compositor Modifier](video_editing/edit/montage/strip_modifiers.xhtml#index-4)   - [Curves Modifier](video_editing/edit/montage/strip_modifiers.xhtml#index-5)   - [Hue Correct Modifier](video_editing/edit/montage/strip_modifiers.xhtml#index-6)   - [Mask Modifier](video_editing/edit/montage/strip_modifiers.xhtml#index-7)   - [Sound Equalizer Modifier](video_editing/edit/montage/strip_modifiers.xhtml#index-10)   - [Tone Map Modifier](video_editing/edit/montage/strip_modifiers.xhtml#index-8)   - [White Balance Modifier](video_editing/edit/montage/strip_modifiers.xhtml#index-9) | - [**Voxel**](glossary/index.xhtml#term-Voxel) |
user: Give a detailed overview of Bevel: syntax, arguments, return values, common patterns.

assistant: Apply a Bevel to turn the 1D line (or 2D ribbon when using [Extrude](#bpy-types-curve-extrude))
into a 3D tube.

### Round

The cross section of the tube becomes a circle (or pill when using Extrude).
You can also get a half circle by changing the [Fill Mode](shape.xhtml#bpy-types-curve-fill-mode).

Depth
:   The size of the cross section.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_geometry_bevel-depth.png   Small Depth. | ../../../_images/modeling_curves_properties_geometry_bevel.png   Large Depth. |

Resolution
:   Drives the number of vertices in the cross section.

    |  |  |
    | --- | --- |
    | ../../../_images/modeling_curves_properties_geometry_bevel-resolution.png   A low Resolution results in a blocky mesh. | ../../../_images/modeling_curves_properties_geometry_bevel.png   A high Resolution results in a smooth mesh. |

Fill Caps
:   Seals the ends of the tube.

### Object

This option lets you fully customize the shape of the cross section by selecting a separate Curve object.

[image reference removed]

Object
:   The curve that defines the cross section. It can be either closed ([cyclic](../editing/curve.xhtml#bpy-ops-curve-cyclic-toggle))
    or open.

### Profile

This option lets you customize the shape of the cross section without having to create a separate
Curve object. However, unlike the *Object* option where the curve defines the full cross section,
the *Profile* in the [Curve Widget](../../../interface/controls/templates/curve.xhtml#ui-curve-widget) only defines a quarter which is then repeated and mirrored.

[image reference removed]

The black dots on the profile represent the points where it’s sampled (that is, where mesh vertices
will be created). You can increase the *Resolution* to get more sample points, and thus a smoother result.

Preset
:   You can choose one of the predefined profiles instead of making your own.
    The *Support Loops* and *Steps* presets are generated dynamically based on the *Resolution*
    and need to be reapplied if you change it.

Reverse Path
:   Mirrors the profile around the diagonal.

Toggle Profile Clipping
:   Limits the X and Y coordinates of control points to the range [0, 1].

Sample Straight Edges
:   Whether to sample the profile in the middle of perfectly straight segments
    (lines between two control points with the *Vector* [handle type](../../../interface/controls/templates/curve.xhtml#ui-curve-widget-handle-type)).
    This is disabled by default, as it’s normally enough to sample the profile at the control
    points themselves.

Sample Even Lengths
:   By default, each profile segment receives the same number of sample points.
    By enabling this option, the sample points are instead distributed evenly
    along the whole length of the profile.
user: Describe Snapping from the Blender manual or Python API, including usage steps and snippets.

assistant: # Snapping

Snapping lets you easily align UV elements to others.
It can be toggled by clicking the magnet icon in the UV Editor’s header,
or more temporarily by holding `Ctrl`.

This page is about the Snap header button; for the Snap menu,
see [UV Editing](../../../modeling/meshes/uv/editing.xhtml#bpy-ops-uv-snap-selected).
user: Provide the full official documentation entry for Damped Track Constraint, preserving all code examples.

assistant: # Damped Track Constraint

The *Damped Track* constraint makes an object or bone point towards a certain target.
It’s typically called “Look At” or “Aim” in other 3D software.

The word “damped” means that the constraint uses a pure [swing](../../../glossary/index.xhtml#term-Swing) rotation
to minimize rolling around the tracking axis. This is in contrast to the
[Track To Constraint](track_to.xhtml) which applies an “Up” axis
in addition to the tracking.
user: Provide the full official documentation entry for LineStyleAlphaModifiers(bpy_struct), preserving all code examples.

assistant: # LineStyleAlphaModifiers(bpy_struct)

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

*class* bpy.types.LineStyleAlphaModifiers(*bpy_struct*)
:   Alpha modifiers for changing line alphas

    new(*name*, *type*)
    :   Add a alpha modifier to line style

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – New name for the alpha modifier (not unique)
            - **type** (enum in [Linestyle Alpha Modifier Type Items](bpy_types_enum_items/linestyle_alpha_modifier_type_items.html#rna-enum-linestyle-alpha-modifier-type-items)) – Alpha modifier type to add

        Returns:
        :   Newly added alpha modifier

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

    remove(*modifier*)
    :   Remove a alpha modifier from line style

        Parameters:
        :   **modifier** ([`LineStyleAlphaModifier`](bpy.types.LineStyleAlphaModifier.html#bpy.types.LineStyleAlphaModifier "bpy.types.LineStyleAlphaModifier"), (never None)) – Alpha modifier 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: What is Glass BSDF and how is it used in Blender Python scripting?

assistant: # Glass BSDF

[image reference removed]

The *Glass* BSDF
is used to add a Glass-like shader mixing refraction and reflection at grazing angles.
Like the transparent shader, only pure white will make it transparent.
The glass shader tends to cause noise due to caustics.
Since the Cycles path tracing integrator is not very good at rendering caustics,
it helps to combine this with a transparent shader for shadows;
for [more details see here](../../cycles/optimizations/reducing_noise.xhtml#render-cycles-reducing-noise-glass-and-transp-shadows).
user: What is Track and how is it used in Blender Python scripting?

assistant: # Track

These tools add a tracking constraint to the selected objects;
the target object of the constraint will be the active object, which won’t have a constraint added.

- [Damped Track Constraint](../../../animation/constraints/tracking/damped_track.html)
- [Track To Constraint](../../../animation/constraints/tracking/track_to.html)
- [Lock Track Constraint](../../../animation/constraints/tracking/locked_track.html)
user: Show practical ways to work with GeometryNodeInputIndex(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeInputIndex(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.GeometryNodeInputIndex(*GeometryNode*)
:   Retrieve an integer value indicating the position of each element in the list, starting at zero

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: Combined with the [Index of Nearest](../geometry/sample/index_of_nearest.xhtml),
this can be used for a number of sphere-based simulations.

[image reference removed]

Index of Nearest sample file CC-BY Sean Christofferson.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`FreestyleLineStyle.thickness_modifiers`](bpy.types.FreestyleLineStyle.html#bpy.types.FreestyleLineStyle.thickness_modifiers "bpy.types.FreestyleLineStyle.thickness_modifiers") - [`LineStyleThicknessModifiers.new`](bpy.types.LineStyleThicknessModifiers.html#bpy.types.LineStyleThicknessModifiers.new "bpy.types.LineStyleThicknessModifiers.new") | - [`LineStyleThicknessModifiers.remove`](bpy.types.LineStyleThicknessModifiers.html#bpy.types.LineStyleThicknessModifiers.remove "bpy.types.LineStyleThicknessModifiers.remove") |
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: Vertex groups can be created manually or generated automatically. They are most commonly used for armature-based
deformation (also called *skinning*), but they are also used in many other areas of Blender, such as:

- Shape keys
- Modifiers
- Particle systems
- Physics simulations
user: Describe Weighted Normal Modifier from the Blender manual or Python API, including usage steps and snippets.

assistant: # Weighted Normal Modifier

This modifier changes the [custom normals](../../meshes/structure.xhtml#modeling-meshes-normals-custom)
of a mesh, using various selectable methods.
This can be useful to make some faces appear very flat during shading, among other effects.
See [Normals](../../meshes/editing/mesh/normals.xhtml) for a description of normals and custom normals.
user: Show practical ways to work with Geometry Node Editor in a Blender add-on or script – include code.

assistant: # Geometry Node Editor

The Geometry Node editor is used to edit [Node Groups](../interface/controls/nodes/groups.xhtml)
which are used by the [Geometry Node Modifier](../modeling/modifiers/geometry_nodes.xhtml).
Such a node group can define many operations to modify an object’s geometry.

A list of all [Geometry Nodes](../modeling/geometry_nodes/index.xhtml) is available in the modeling section.
Also see the [Nodes](../interface/controls/nodes/index.xhtml) page for information on working with
nodes in general.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Interpolation
:   Method to scale images up or down for sampling.

    Linear:
    :   Regular quality interpolation.

    Cubic:
    :   Smoother, better quality interpolation. For bump maps this should be used to get best results.

    Closest:
    :   No interpolation, use only closest pixel for rendering pixel art.

Extension
:   Extension defines how the image is extrapolated past the original bounds:

    Repeat:
    :   Will repeat the image horizontally and vertically giving tiled-looking result.

    Extend:
    :   Will extend the image by repeating pixels on its edges.

    Clip:
    :   Clip to the original image size and set all the exterior pixels values to transparent black.

    Mirror:
    :   Repeatedly flip the image horizontally and vertically.
user: Show practical ways to work with Point Light in a Blender add-on or script – include code.

assistant: [image reference removed]

Point light.

The point light is an omnidirectional point of light,
that is, a point radiating the same amount of light in all directions.
It’s visualized by a plain, circled dot.
Being a point light source, the direction of the light hitting an object’s surface
is determined by the line joining the light and the point on the surface of the object itself.
It can be used as simple model of e.g. a light bulb.

Light intensity/energy decays based on (among other variables)
distance from the point light to the object. In other words,
surfaces that are further away will be rendered darker.

Power
:   Power of the light. Higher values increase the intensity of the light.
    Negative values can be set, but should be avoided for predictable and physically based result.

Radius
:   When larger than zero, light will be emitted from a spherical surfaces with the specified radius.
    Lights with larger size have softer shadows and specular highlights, and they will also appear dimmer
    because their power is distributed over a larger area.

Soft Falloff
:   Apply falloff to avoid sharp edges when the light geometry intersects with other objects.
user: What is FollowPathConstraint(Constraint) and how is it used in Blender Python scripting?

assistant: # FollowPathConstraint(Constraint)

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

*class* bpy.types.FollowPathConstraint(*Constraint*)
:   Lock motion to the target path

    forward_axis
    :   Axis that points forward along the path

        Type:
        :   enum in [`'FORWARD_X'`, `'FORWARD_Y'`, `'FORWARD_Z'`, `'TRACK_NEGATIVE_X'`, `'TRACK_NEGATIVE_Y'`, `'TRACK_NEGATIVE_Z'`], default `'FORWARD_X'`

    offset
    :   Offset from the position corresponding to the time frame

        Type:
        :   float in [-1.04857e+06, 1.04857e+06], default 0.0

    offset_factor
    :   Percentage value defining target position along length of curve

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

    target
    :   Target Curve object

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

    up_axis
    :   Axis that points upward

        Type:
        :   enum in [`'UP_X'`, `'UP_Y'`, `'UP_Z'`], default `'UP_X'`

    use_curve_follow
    :   Object will follow the heading and banking of the curve

        Type:
        :   boolean, default False

    use_curve_radius
    :   Object is scaled by the curve radius

        Type:
        :   boolean, default False

    use_fixed_location
    :   Object will stay locked to a single point somewhere along the length of the curve regardless of time

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Plane and how is it used in Blender Python scripting?

assistant: # Plane

Moves vertices toward or away from the brush plane along its normal direction.

The *Plane* brush flattens geometry to a virtual plane
or raises the surface relative to it, depending on brush settings.
The *Height* and *Depth* parameters control the range of influence above and below the plane,
allowing precise shaping of flat surfaces or plateaus.
user: What is Stack and how is it used in Blender Python scripting?

assistant: # Stack

The list of constraints affecting an object or bone is called the *Constraint Stack*.
It’s evaluated from top to bottom, and reordering it can drastically change the outcome.

[image reference removed]

Moving constraints is done by dragging their handle  with `LMB`.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Image
:   The texture to distort.

UV
:   The UV coordinates at which to sample the texture. The UV coordinates can either come directly from the UV render
    pass (Cycles only, see [Cycles render passes](../../../render/layers/passes.html)), or from the image coordinates
    in which case the Z component must be manually set to 1 (see example below).

### Sampling

Interpolation
:   Determines how pixel values are interpolated when scaling or transforming images.

    Nearest:
    :   Uses the value of the closest pixel with no smoothing.
        This is the fastest method and is well-suited for pixel art or low-resolution images
        where sharp, blocky edges are desirable.
        In animations, motion appears in single-pixel steps, which can cause visible jittering.

    Bilinear:
    :   Averages the values of surrounding pixels to create a smoother result than *Nearest*.
        Provides a good balance between performance and visual quality.

    Bicubic:
    :   Computes a weighted average of a larger neighborhood of pixels for even smoother results.
        Ideal for photographic images or gradients where preserving fine detail is important.

    Anisotropic:
    :   Adjusts interpolation based on the direction and scale of the transformation.
        Helps reduce blurring or aliasing when scaling at steep angles or uneven resolutions,
        especially useful in textures viewed at oblique angles or in detailed 3D projections.

Extension X/Y
:   The extension mode applied to the X axis.

    Clip:
    :   Areas outside of the image are filled with transparency.

    Extend:
    :   Areas outside of the image are filled with the closest boundary pixel in the image.

    Repeat:
    :   Areas outside of the image are filled with repetitions of the image.
user: Show practical ways to work with Tool Context in a Blender add-on or script – include code.

assistant: These popover menus are displayed in the header when the tool context is enabled.
These properties determine where the tool is available in the user interface.

See [Supported Modes & Object Types](../modeling/geometry_nodes/tools.xhtml#modeling-geometry-nodes-tools-contexts) for more information.

### Types

The [Object Types](../scene_layout/object/types.xhtml) the tool supports.

Mesh
:   The node tree supports [Mesh Objects](../modeling/meshes/index.xhtml).

Hair Curves
:   The node tree supports [Curve Objects](../modeling/curves/index.xhtml).

Grease Pencil
:   The node tree supports [Grease Pencil Objects](../grease_pencil/index.xhtml).

Point Cloud
:   The node tree supports [Point Cloud Objects](../modeling/point_cloud/index.xhtml).

### Modes

The [Object Modes](3dview/modes.xhtml) the tool supports.

Object Mode
:   The node group can be used in Object mode.

Edit Mode
:   The node group can be used in edit mode.

Sculpt Mode
:   The node group can be used in [Sculpt Mode](../sculpt_paint/sculpting/index.xhtml).

Draw Mode Grease Pencil
:   The node group can be used in Grease Pencil [Draw Mode](../grease_pencil/modes/draw/index.xhtml).

### Options

Wait for Click
:   Wait for a mouse click input (`LMB`) before running the operator from a menu.
    This is useful for the [Mouse Position Node](../modeling/geometry_nodes/input/scene/mouse_position.xhtml).
user: Give a detailed overview of Set Curve Type: syntax, arguments, return values, common patterns.

assistant: Converts splines in a curve object between Bézier, NURBS, Poly, and Catmull Rom types.
This is a basic conversion, meaning Blender does not preserve the exact shape or the number of control points.
For example, converting a NURBS spline to a Bézier spline maps each group of three NURBS control points
to a single Bézier control point with two handles.

Type
:   Specifies the target spline type. For more details on spline types, see the
    [Spline Types](../../curves/structure.xhtml#curve-spline-types) documentation.

    Bézier:
    :   Converts the spline to a Bézier type.
        - Poly splines are converted with vector handles.
        - NURBS or Catmull Rom splines are converted with automatic handles.

    NURBS:
    :   Converts the spline to a NURBS type.

    Poly:
    :   Converts the spline to a poly type.

    Catmull Rom:
    :   Converts the spline to a Catmull Rom type.

Handles
:   Includes handle information during the conversion process.
user: How do I use GeometryNodeSetMeshNormal(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeSetMeshNormal(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.GeometryNodeSetMeshNormal(*GeometryNode*)
:   Store a normal vector for each mesh element

    domain
    :   Attribute domain to store free custom normals

        Type:
        :   enum in [Attribute Domain Only Mesh No Edge Items](bpy_types_enum_items/attribute_domain_only_mesh_no_edge_items.html#rna-enum-attribute-domain-only-mesh-no-edge-items), default `'POINT'`

    mode
    :   Storage mode for custom normal data

        - `SHARPNESS`
          Sharpness – Store the sharpness of each face or edge. Similar to the “Shade Smooth” and “Shade Flat” operators..
        - `FREE`
          Free – Store custom normals as simple vectors in the local space of the mesh. Values are not necessarily updated automatically later on as the mesh is deformed..
        - `TANGENT_SPACE`
          Tangent Space – Store normals in a deformation dependent custom transformation space. This method is slower, but can be better when subsequent operations change the mesh without handling normals specifically..

        Type:
        :   enum in [`'SHARPNESS'`, `'FREE'`, `'TANGENT_SPACE'`], default `'SHARPNESS'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

Spline IK constraint.

[Target](../interface/common.html#rigging-constraints-interface-common-target)
:   The Curve whose shape to match.

[Influence](../interface/common.html#bpy-types-constraint-influence)
:   How strongly the constraint affects the bone chain.

### Fitting

Chain Length
:   The number of bones affected by the constraint, starting with the owner bone
    and walking up its chain of ancestors. A value of 1 will only fit the bone
    itself, a value of 2 will fit the bone and its parent, and so on.

Even Divisions
:   When disabled, each bone will cover a distance along the curve relative to its
    rest length. When enabled, each bone will cover the same distance regardless
    of its rest length.

Chain Offset
:   When disabled, the bone chain will move to match the position of the curve.
    When enabled, the bone chain will stay at its original starting location and
    mimic the shape of the curve from there.

### Chain Scaling

Use Curve Radius
:   Whether to use the [radii](../../../modeling/curves/editing/curve.html#modeling-curve-radius) of the curve control points
    as additional X and Z scaling factors for the bones.

Y Scale Mode
:   How to stretch the bones along the length of the curve.

    None:
    :   Reset the bones to their rest length.

    Fit Curve:
    :   Stretch the bones to cover the entire length of the curve.

    Bone Original:
    :   Keep the bones’ original length (including their Pose Mode scale).

XZ Scale Mode
:   How to scale the bones along the normals of the curve (or in other words, how to determine
    the thickness of the bones).

    None:
    :   Reset the bones’ X and Z scales to 1.

    Bone Original:
    :   Keep the bones’ original X and Z scales from Pose Mode.

    Inverse Scale:
    :   Set the X and Z scales to the inverse of the Y scale.

    Volume Preservation:
    :   Similar to the [Stretch To](stretch_to.html#constraints-stretch-to-volume-preservation) constraint.

Use Original Scale
:   Apply *Inverse Scale* or *Volume Preservation* on top of the Pose Mode bone scales,
    like in the Stretch To constraint.
user: Provide the full official documentation entry for BSDF Parameters, preserving all code examples.

assistant: A major difference from non-physically-based renderers is that direct light reflection from
lights and indirect light reflection of other surfaces are not decoupled, but rather handled
using a single BSDF.
This limits the possibilities a bit, but we believe overall it is helpful in creating
consistent-looking renders with fewer parameters to tune.

Roughness
:   For the glossy BSDFs,
    the *roughness* parameter controls the sharpness of the reflection, from 0.0 (perfectly sharp)
    to 1.0 (very soft).
user: How do I use Bpy.Ops.Asset in Blender? Include parameters, examples, warnings and best practices.

assistant: wser, with the help of customizable metadata (like previews, descriptions and tags) bpy.ops.asset. mark_single ( ) ¶ Enable easier reuse of a data-block through the Asset Browser, with the help of customizable metadata (like previews, descriptions and tags) bpy.ops.asset. open_containing_blend_file ( ) ¶ Open the blend file that contains the active asset File : startup/bl_operators/assets.py:103 bpy.ops.asset. screenshot_preview ( * , p1 = (0, 0) , p2 = (0, 0) , force_square = True ) ¶ Capture a screenshot to use as a preview for the selected asset Parameters : p1 ( int array of 2 items in [ 0 , inf ] , ( optional ) ) – Point 1, First point of the screenshot in screenspace p2 ( int array of 2 items in [ 0 , inf ] , ( optional ) ) – Point 2, Second point of the screenshot in screenspace force_square ( boolean , ( optional ) ) – Force Square, If enabled, the screenshot will have the same height as width bpy.ops.asset. tag_add ( ) ¶ Add a new keyword tag to the active asset File : startup/bl_operators/assets.py:42 bpy.ops.asset. tag_remove ( ) ¶ Remove an existing keyword tag from the active asset File : startup/bl_operators/assets.py:65 Next Boid Operators Previous Armature Operators Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page Asset Operators assign_action() bundle_install() catalog_delete() catalog_new() catalog_redo() catalog_undo() catalog_undo_push() catalogs_save() clear() clear_single() library_refresh() mark() mark_single() open_containing_blend_file() screenshot_preview() tag_add() tag_remove()
user: Show practical ways to work with Convert to Display Node in a Blender add-on or script – include code.

assistant: # Convert to Display Node

[image reference removed]

The *Convert to Display* node applies an [OpenColorIO](../../../render/color_management/opencolorio.xhtml)
[display, view, and look transform](../../../render/color_management/displays_views.xhtml)
to an image in the *scene linear* color space.
It converts linear render data into a color-accurate representation for a specific display and view
combination, following the configuration defined in the active color management settings.

This node complements the [Convert Colorspace](convert_colorspace.xhtml) node
by supporting display-view-look combinations, which are not represented as individual color spaces
in modern OCIO configurations.
Unlike *Convert Colorspace*, this node reproduces the same color management transforms used by
the *Save As Render* option or the *Render View* display.
user: Explain Stitch in complete detail according to the official Blender documentation.

assistant: The *Stitch* tool, will join selected UVs that share vertices.
You set the tool to limit stitching by distance in the [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel,
by activating *Use Limit* and adjusting the *Limit Distance*.
user: Explain LatticePoint(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # LatticePoint(bpy_struct)

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

*class* bpy.types.LatticePoint(*bpy_struct*)
:   Point in the lattice grid

    co
    :   Original undeformed location used to calculate the strength of the deform effect (edit/animate the Deformed Location instead)

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

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

    groups
    :   Weights for the vertex groups this point is member of

        Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`VertexGroupElement`](bpy.types.VertexGroupElement.html#bpy.types.VertexGroupElement "bpy.types.VertexGroupElement"), (readonly)

    select
    :   Selection status

        Type:
        :   boolean, default False

    weight_softbody
    :   Softbody goal weight

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Resolution
:   The number of edges on the curve.

Start, End
:   Positions of the start and end control point of the curve.

Start Handle, End Handle
:   Positions of the handles used to define the shape of the curve.