PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is Clean Up and how is it used in Blender Python scripting?

assistant: These tools help to cleanup degenerate geometry on the strokes.

### Clean Loose Points

Removes strokes with only a few points.

Limit
:   The number of points to consider a stroke as loose.

### Delete Duplicate Frames

Removes any duplicate keyframes.

### Merge by Distance

Simplifies a stroke by merging the selected points that are closer than a specified distance to each other.
Note, unless using *Unselected*, selected points must be contiguous, else they will not be merged.

Merge Distance
:   Sets the distance threshold for merging points.

Unselected
:   Allows points in selection to be merged with unselected points.
    When disabled, selected points will only be merged with other selected ones.

### Reproject Strokes

Sometimes you may have drawn strokes unintentionally in different locations in the 3D space
but they look right from a certain plane or from the camera view.
You can use Reproject to flatten all the selected strokes from a certain viewpoint.

Reprojected Type
:   Front:
    :   Reproject selected strokes onto the front plane (XZ).

    Side:
    :   Reproject selected strokes onto the side plane (YZ).

    Top:
    :   Reproject selected strokes onto the top plane (XY).

    View:
    :   Reproject selected strokes onto the current view.

    Surface:
    :   Reproject selected strokes onto the mesh surfaces.

        Surface Offset
        :   When Surface Mode is activated controls the stroke offset from the object.

    Cursor:
    :   Reproject selected strokes onto 3D cursor rotation.

Keep Original
:   Maintains the original strokes after applying the tool.

|  |  |  |  |
| --- | --- | --- | --- |
| ../../../_images/grease-pencil_modes_edit_grease-pencil-menu_reproject-strokes-1.png   Original drawing from the front view. | ../../../_images/grease-pencil_modes_edit_grease-pencil-menu_reproject-strokes-2.png   Original drawing in the 3D Viewport. | ../../../_images/grease-pencil_modes_edit_grease-pencil-menu_reproject-strokes-3.png   Strokes reprojected onto the front plane to fix strokes misalignment. | ../../../_images/grease-pencil_modes_edit_grease-pencil-menu_reproject-strokes-1.png   Drawing after reprojection operation from the front view. |
user: Explain Usage in complete detail according to the official Blender documentation.

assistant: Closures define reusable logic that can be injected into another node tree. They are commonly used in procedural systems
where part of the behavior should remain user-defined.

Typical use cases include:

- Defining a custom scattering rule for a terrain generator.
- Describing how to distribute or modify instances procedurally.
- Providing adjustable mappings, field evaluations, or transformation logic.

### Using External Values

Closures can *capture* values from outside their zone. A captured value is stored as part of the closure definition and
remains available even when the closure is evaluated in a different context.

Captured values make it possible to preserve external parameters—such as scale, density, or color—without creating
explicit input sockets. This makes closures cleaner and easier to reuse in different node trees.

[image reference removed]

Capturing an external input value inside a closure.

### Example

1. In a terrain generator node group, replace the tree distribution logic with an
   [Evaluate Closure](../../../interface/controls/nodes/types/utilities/closure/evaluate_closure.xhtml) node.
2. Expose the closure input on the group’s interface.
3. In the main node tree, create a *Closure Zone* and connect it to that input.
4. Inside the closure zone, define the desired tree placement logic.

When the generator evaluates the closure, the custom distribution defined in the zone is executed instead of the
default behavior.

[image reference removed]

A *Closure Zone* defining a custom distribution pattern for tree scattering.
user: Explain Connect Vertex Pairs in complete detail according to the official Blender documentation.

assistant: # Connect Vertex Pairs

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

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

The main difference between this operator and [Connect Vertex Path](connect_vertex_path.html)
is that this operator ignores the selection order and connects all selected vertices that share a face.
user: Show practical ways to work with Other Useful Links in a Blender add-on or script – include code.

assistant: - [Blender FAQ](https://www.blender.org/support/faq/) (Can I use Blender commercially? What is GPL/GNU? …)
- [Demo and benchmark files](https://www.blender.org/download/demo-files/)
- Developer’s [Ask Us Anything!](https://developer.blender.org/docs/handbook/new_developers/faq/)
user: Describe String Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # String Node

[image reference removed]

The *String* input node creates a single string. It can be connected to attribute name sockets
to make using the same attribute name in multiple places more convenient.
user: How do I use Introduction in Blender? Include parameters, examples, warnings and best practices.

assistant: # Introduction

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

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

You may limit the effect on particles to a group of objects
(see the [Particle Physics](../../particles/emitter/physics/index.xhtml) page).
user: Describe MESH_UL_color_attributes_selector(UIList) from the Blender manual or Python API, including usage steps and snippets.

assistant: # MESH_UL_color_attributes_selector(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.MESH_UL_color_attributes_selector(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *attribute*, *_icon*, *_active_data*, *_active_propname*, *_index*)

    filter_items(*_context*, *data*, *property*)

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

assistant: From Instancer Cycles Only
:   See the [From Instancer](texture_coordinate.html#cycles-nodes-input-texture-coordinate-from-instancer)
    option of the [Texture Coordinate Node](texture_coordinate.html).

UV Map
:   The name of the [UV map](../../../modeling/meshes/uv/uv_texture_spaces.html#uv-maps-panel) to use.
    This list is populated from the UV maps available on the object’s mesh data-block.
    If left unset, the [Active Render](../../../modeling/meshes/uv/uv_texture_spaces.html#bpy-types-meshuvlooplayer-active-render) UV map is used.
user: How do I use Set Curve Normal Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Set Curve Normal Node

[image reference removed]

The *Set Curve Normal* controls the method used to calculate curve normals for every curve.

The node doesn’t set the normals directly, those are calculated later as necessary.
Combined with the [tilt](../read/curve_tilt.xhtml) attribute value
at each control point, this will define the final normals accessible with the
[Normal Node](../../geometry/read/normal.xhtml).

Internally this node adjusts the values of the `normal_mode` attribute on each curve.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.strip_modifier`](bpy.context.html#bpy.context.strip_modifier "bpy.context.strip_modifier") - [`Strip.modifiers`](bpy.types.Strip.html#bpy.types.Strip.modifiers "bpy.types.Strip.modifiers") - [`StripModifiers.active`](bpy.types.StripModifiers.html#bpy.types.StripModifiers.active "bpy.types.StripModifiers.active") | - [`StripModifiers.new`](bpy.types.StripModifiers.html#bpy.types.StripModifiers.new "bpy.types.StripModifiers.new") - [`StripModifiers.remove`](bpy.types.StripModifiers.html#bpy.types.StripModifiers.remove "bpy.types.StripModifiers.remove") |
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Unsigned Angle
:   The shortest angle in radians between two faces where they meet at an edge.
    The range of the data is from zero to PI. Flat edges and [Non-manifold](../../../../glossary/index.xhtml#term-Non-manifold)
    edges have an angle of zero. An edge between two faces completely folded
    back on each other has an angle of PI, or 180 degrees.

Signed Angle
:   The signed angle in radians between two faces where they meet at an edge. Flat edges
    and Non-manifold edges have an angle of zero. Concave angles are positive and convex
    angles are negative.
user: What is Face Set Gesture Tools and how is it used in Blender Python scripting?

assistant: # Face Set Gesture Tools

Face Set gesture tools apply a single new Face Set to all faces within the selection area.

All Face Set gesture tools can be activated in the Toolbar and are comprised of the following:
user: What is Inherited Properties and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`UIList.bl_idname`](bpy.types.UIList.html#bpy.types.UIList.bl_idname "bpy.types.UIList.bl_idname") - [`UIList.list_id`](bpy.types.UIList.html#bpy.types.UIList.list_id "bpy.types.UIList.list_id") - [`UIList.layout_type`](bpy.types.UIList.html#bpy.types.UIList.layout_type "bpy.types.UIList.layout_type") - [`UIList.use_filter_show`](bpy.types.UIList.html#bpy.types.UIList.use_filter_show "bpy.types.UIList.use_filter_show") - [`UIList.filter_name`](bpy.types.UIList.html#bpy.types.UIList.filter_name "bpy.types.UIList.filter_name") | - [`UIList.use_filter_invert`](bpy.types.UIList.html#bpy.types.UIList.use_filter_invert "bpy.types.UIList.use_filter_invert") - [`UIList.use_filter_sort_alpha`](bpy.types.UIList.html#bpy.types.UIList.use_filter_sort_alpha "bpy.types.UIList.use_filter_sort_alpha") - [`UIList.use_filter_sort_reverse`](bpy.types.UIList.html#bpy.types.UIList.use_filter_sort_reverse "bpy.types.UIList.use_filter_sort_reverse") - [`UIList.use_filter_sort_lock`](bpy.types.UIList.html#bpy.types.UIList.use_filter_sort_lock "bpy.types.UIList.use_filter_sort_lock") - [`UIList.bitflag_filter_item`](bpy.types.UIList.html#bpy.types.UIList.bitflag_filter_item "bpy.types.UIList.bitflag_filter_item") - [`UIList.bitflag_item_never_show`](bpy.types.UIList.html#bpy.types.UIList.bitflag_item_never_show "bpy.types.UIList.bitflag_item_never_show") |
user: How do I use GeometryNodeCurveToPoints(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeCurveToPoints(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.GeometryNodeCurveToPoints(*GeometryNode*)
:   Generate a point cloud by sampling positions along curves

    mode
    :   How to generate points from the input curve

        - `EVALUATED`
          Evaluated – Create points from the curve’s evaluated points, based on the resolution attribute for NURBS and Bézier splines.
        - `COUNT`
          Count – Sample each spline by evenly distributing the specified number of points.
        - `LENGTH`
          Length – Sample each spline by splitting it into segments with the specified length.

        Type:
        :   enum in [`'EVALUATED'`, `'COUNT'`, `'LENGTH'`], default `'COUNT'`

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

assistant: ### Principled Volume

[Principled Volume](../../shader_nodes/shader/volume_principled.xhtml)
is a physically-based volume shader that can be used to create a wide range of volume materials.
It supports scattering, absorption and emission in one easy to use node.
Fire can be rendered with blackbody emission.

[image reference removed]

Smoke and fire rendered with Principled Volume shader.

### Volume Components

For more control, volume shading components can be manually combined into a custom shader setup.

- [Volume Absorption](../../shader_nodes/shader/volume_absorption.xhtml)
  will absorb part of the light as it passes through the volume.
  This can be used to shade for example black smoke or colored glass objects, or mixed with the Volume Scatter node.
  This node is similar to the transparent BSDF node,
  it blocks part of the light and lets other light pass straight through.
- [Volume Scatter](../../shader_nodes/shader/volume_scatter.xhtml)
  lets light scatter in other directions as it hits particles in the volume.
  The anisotropy defines in which direction the light is more likely to scatter.
  A value of 0 will let light scatter evenly in all directions (similar to the diffuse BSDF node),
  negative values let light scatter mostly backwards, and positive values let light scatter mostly forward.
  This can be used to shade white smoke or clouds for example.
- [Emission](../../shader_nodes/shader/emission.xhtml)
  will emit light from the volume, for example for fire.

[image reference removed]

Volume Absorption, Scatter and Emission

### Attributes

When rendering smoke and fire, volume attributes are used to define the shape and shading of the volume.
The Principled Volume shader will use them by default, while custom volume shaders can use
the Attribute node to get attributes such as density, color and temperature.

### Density

All volume shaders have a density input.
The density defines how much of the light will interact with the volume,
getting absorbed or scattered, and how much will pass straight through. For effects such as
smoke you would specify a density field to indicate where in the volume there is smoke and
how much (density bigger than 0), and where there is no smoke (density equals 0).

Volumes in the real world consist of particles,
a higher density means there are more particles per unit volume. More particles means there is
a higher chance for light to collide with a particle and get absorbed or scattered,
rather than passing straight through.
user: Show practical ways to work with Quality in a Blender add-on or script – include code.

assistant: Viewport Anti-Aliasing
:   Control the [Anti-Aliasing](../../glossary/index.xhtml#term-Anti-Aliasing) for higher quality rendering.

Smooth Wires
:   Overlay
    :   Display overlays with smooth wire, without this wires will be rendered aliased.
        To increase the visibility you can disable this for Edit Mode specificity (see below),
        since edges do not blend into other shaded regions.

    Edit Mode
    :   Display smooth wire in Edit Mode, without this wires will be rendered aliased.
user: Explain ColorRampElements(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # ColorRampElements(bpy_struct)

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

*class* bpy.types.ColorRampElements(*bpy_struct*)
:   Collection of Color Ramp Elements

    new(*position*)
    :   Add element to Color Ramp

        Parameters:
        :   **position** (*float in* *[**0**,* *1**]*) – Position, Position to add element

        Returns:
        :   New element

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

    remove(*element*)
    :   Delete element from Color Ramp

        Parameters:
        :   **element** ([`ColorRampElement`](bpy.types.ColorRampElement.html#bpy.types.ColorRampElement "bpy.types.ColorRampElement"), (never None)) – Element 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: Show practical ways to work with AssetLibraryCollection(bpy_struct) in a Blender add-on or script – include code.

assistant: # AssetLibraryCollection(bpy_struct)

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

*class* bpy.types.AssetLibraryCollection(*bpy_struct*)
:   Collection of user asset libraries

    *classmethod* new(*\**, *name=''*, *directory=''*)
    :   Add a new Asset Library

        Parameters:
        :   - **name** (*string**,* *(**optional**,* *never None**)*) – Name
            - **directory** (*string**,* *(**optional**,* *never None**)*) – Directory

        Returns:
        :   Newly added asset library

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

    *classmethod* remove(*library*)
    :   Remove an Asset Library

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

assistant: # Corner Pin Node

[image reference removed]

The Corner Pin node uses explicit corner values for a plane warp transformation.
It works like the [Plane Track Deform](../tracking/plane_track_deform.xhtml) node,
but without using “plane track” data from the Movie Clip Editor.
user: What is Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

Collision panel.

### Collision

Field Absorption
:   A deflector can also deflect effectors. You can specify some collision/deflector objects which deflect
    a specific portion of the effector force using the *Field Absorption* value. 100% absorption results in no force
    getting through the collision/deflector object at all. If you have three collision object behind each other with
    e.g. 10%, 43% and 3%, the absorption ends up at around 50% \(100 × (1 - 0.1) × (1 - 0.43) × (1 - 0.03)\).

### Particle

Permeability
:   Fraction of particles passing through the mesh.

Stickiness
:   How much particles stick to the object.

Kill Particles
:   Deletes Particles upon impact.

Damping
:   Damping during a collision (independent of the velocity of the particles).

    Randomize
    :   Random variation of damping.

Friction
:   Friction during movements along the surface.

    Randomize
    :   Random variation of friction.

### Soft Body and Cloth

It is also important to note that this collision panel is used to tell
all simulations that this object is to participate in colliding/deflecting other objects
on a shared layer (particles, soft bodies, and cloth).

[image reference removed]

Collision stack.

Damping
:   Damping during a collision.
    The amount of bounce that the surfaces will have.

    - 0.0 - No damping, soft bodies will have a maximum bounciness.
    - 1.0 - Maximum damping, soft bodies will not bounce at all.

Thickness
:   A padding distance is added to the inside and outside of each face, to help to prevent intersections.
    The soft body will come to rest at this distance away from the face of the colliding object.
    Outside and inside is defined by the face normal, depicted as blue arrow in Fig. [A soft body vertex colliding with a plane.](#fig-collision-soft-plane).

    Outer
    :   Size of the outer collision zone.

    Inner
    :   Size of the inner collision zone (padding distance).

[image reference removed]

A soft body vertex colliding with a plane.

Friction
:   A coefficient for how slippery the cloth is when it collides with itself.
    For example, silk has a lower coefficient of friction than cotton.

Single Sided
:   When enabled, the collider is considered to represent the boundary of a solid object
    rather than a thin surface, and ejects intersecting cloth in the direction of its normal.

Override Normals
:   When enabled, cloth collision impulses act in the direction of the collider normals.
user: Provide the full official documentation entry for Move on Axis, preserving all code examples.

assistant: Moves selected UV coordinates along a chosen axis by a specified distance.
This operator is designed for precise UV adjustments and supports multiple
movement modes. It is especially useful when combined with the number pad keys
for quick directional nudging.

Use the following shortcuts to move UVs directly from the keyboard:

- `Numpad8` / `Numpad2`: Move up or down.
- `Numpad4` / `Numpad6`: Move left or right.

Type
:   The movement unit type.

    Dynamic:
    :   Move using the active grid size.
        Holding `Ctrl` while pressing a number pad key activates this mode.

    Pixel:
    :   Move by pixel increments.
        Holding `Shift` while pressing a number pad key activates this mode.

    UDIM:
    :   Move by full UV tiles (1.0 UV unit).
        Using the number pad keys with no modifying keys uses this mode.

Axis
:   The axis along which to move the UVs.

    X Axis:
    :   Move vertices horizontally.

    Y Axis:
    :   Move vertices vertically.

Distance
:   The distance to move the UVs, measured in the selected unit type.
user: Explain Vortex in complete detail according to the official Blender documentation.

assistant: # Vortex

[image reference removed]

Vortex force field visualization.

The *Vortex* force field gives a spiraling force that twists the direction of points around the force
object’s local Z axis. This can be useful for making a swirling sink, or tornado,
or kinks in particle hair.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: The output of the node is dynamic. It is either a vector or a scalar depending on the operator.
For instance, the *Length* operator has a scalar output while the *Add* operator has a vector output.

Vector
:   Output vector.

Value
:   Output value.
user: Show practical ways to work with SelectedUvElement(PropertyGroup) in a Blender add-on or script – include code.

assistant: # SelectedUvElement(PropertyGroup)

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

*class* bpy.types.SelectedUvElement(*PropertyGroup*)
:   element_index
    :   Type:
        :   int in [0, inf], default 0

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Metaball Properties

All metaball objects of a same [family](editing.xhtml#meta-ball-object-families) in a scene interact with each other.
The settings in the *Metaball* section apply to all meta objects of the active family. In Edit Mode,
the *Active Element* panel is shown for [editing](editing.xhtml#meta-ball-editing) individual metaball elements.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Instances
:   Standard geometry input.

Selection
:   Boolean field used to determine if an instance will be rotated.

Rotation
:   The [Euler](../../../glossary/index.xhtml#term-Euler) rotation to rotate the instances by.

Pivot Point
:   The position around which each instance is rotated. If the *Local Space* input is true,
    the location is relative to the initial transform of the instance.

Local Space
:   If enabled, the instances are rotated in local space. In other words,
    they are rotated around the axes described by the initial transform of each instance.
    When the input is disabled, the pivot point and rotation are specified in
    the local space of the modifier object.
user: What is Color Spill Node and how is it used in Blender Python scripting?

assistant: # Color Spill Node

[image reference removed]

The *Color Spill* node is used to suppress unwanted color casts—typically green or blue;
caused by light reflecting from a chroma key (green or blue screen) onto the subject.

This “spill” is common in compositing workflows and can give a subject an unnatural colored tint.
The node reduces the influence of the selected color channel,
removing the excess and restoring a more natural appearance.
user: Show practical ways to work with Bpy.Types.Constraint in a Blender add-on or script – include code.

assistant: ons ¶ bpy_struct.as_pointer bpy_struct.driver_add bpy_struct.driver_remove bpy_struct.get bpy_struct.id_properties_clear bpy_struct.id_properties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values References ¶ Object.constraints ObjectConstraints.active ObjectConstraints.copy ObjectConstraints.copy ObjectConstraints.new ObjectConstraints.remove Panel.custom_data PoseBone.constraints PoseBoneConstraints.active PoseBoneConstraints.copy PoseBoneConstraints.copy PoseBoneConstraints.new PoseBoneConstraints.remove UILayout.template_constraint_header Next ConstraintTarget(bpy_struct) Previous ConsoleLine(bpy_struct) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page Constraint(bpy_struct) Constraint Constraint.active Constraint.enabled Constraint.error_location Constraint.error_rotation Constraint.influence Constraint.is_override_data Constraint.is_valid Constraint.mute Constraint.name Constraint.owner_space Constraint.show_expanded Constraint.space_object Constraint.space_subtarget Constraint.target_space Constraint.type Constraint.bl_rna_get_subclass() Constraint.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Provide the full official documentation entry for Visual Transform, preserving all code examples.

assistant: Constraints give their owning object or bone a new location, rotation, and/or scale which together
are called the *visual transform*. This transform is separate from the “base” transform found
in the *Transform* panel of the Properties Editor,
and as its name implies, it determines where the owner *really* appears in the world.

For example, even when an object’s *Transform* panel still shows the original *Location* of (0, 0, 0),
a constraint could have placed it somewhere else entirely. What’s more, attempting to move or even
animate that object won’t work: its *Location* numbers will change, but visually,
it will remain stuck in place. The only way to “free” the object is to disable or delete the constraint,
or to set its [Influence](interface/common.html#bpy-types-constraint-influence) to zero.

Of course, transform properties that are not constrained can still be changed as usual.

While the visual transform is not shown in the UI, it can be copied to the base transform:

- By running [Apply Visual Transform](../../scene_layout/object/editing/apply.html#bpy-ops-object-visual-transform-apply).
- By [applying](interface/header.html#bpy-ops-constraint-apply) the constraint. This also deletes the constraint.
user: Give a detailed overview of MagicTexture(Texture): syntax, arguments, return values, common patterns.

assistant: # MagicTexture(Texture)

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

*class* bpy.types.MagicTexture(*Texture*)
:   Procedural noise texture

    noise_depth
    :   Depth of the noise

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

    turbulence
    :   Turbulence of the noise

        Type:
        :   float in [0.0001, inf], default 5.0

    users_material
    :   Materials that use this texture

        Type:
        :   tuple of [`Material`](bpy.types.Material.html#bpy.types.Material "bpy.types.Material")

        (readonly)

    users_object_modifier
    :   Object modifiers that use this texture

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: As with other objects,
*Ray Visibility* allows you to control which other shaders can “see” the environment.

### Tricks

Sometimes it may be useful to have a different background that is directly visible versus one
that is indirectly lighting the objects. A simple solution to this is to add a Mix node,
with the *Blend Factor* set to *Is Camera Ray*. The first input color is then the indirect color,
and the second the directly visible color. This is useful when using a high-res image for
the background and a low-res image for the actual lighting.

Similarly, adding the *Is Camera* and *Is Glossy* rays will mean that the high-res image
will also be visible in reflections.

[image reference removed]

Nodes for the trick above.
user: Describe Dope Sheet Overlays from the Blender manual or Python API, including usage steps and snippets.

assistant: # Dope Sheet Overlays

Clicking  (Show Overlays) toggles all overlays in the Dope Sheet.

The drop-down button displays a popover with more detailed settings, which are described below.

Show Scene Strip Range
:   When using [scene time synchronization](../../../interface/window_system/workspaces.xhtml#bpy-types-workspace-use-scene-time-sync)
    in the [Sequence Editor](../../video_sequencer/index.xhtml), display the range of the current scene strip.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Selection
:   Faces to participate in the unwrap operation.
    UVs that are part of any other face will not be affected.

Seam
:   Edges to mark where the mesh is “cut” for the purposes of unwrapping.

Margin
:   The distance to leave between UV islands.

Fill Holes
:   Virtually fill holes in mesh before unwrapping, to better avoid overlaps and preserve symmetry.

Method
:   Angle Based:
    :   This method gives a good 2D representation of a mesh.

    Conformal:
    :   Uses LSCM (Least Squares Conformal Mapping). This usually gives a less accurate UV
        mapping than Angle Based, but works better for simpler objects.
user: Explain Driver Target Rotation Mode Items in complete detail according to the official Blender documentation.

assistant: # Driver Target Rotation Mode Items

AUTO:
:   Auto Euler.

    Euler using the rotation order of the target.

XYZ:
:   XYZ Euler.

    Euler using the XYZ rotation order.

XZY:
:   XZY Euler.

    Euler using the XZY rotation order.

YXZ:
:   YXZ Euler.

    Euler using the YXZ rotation order.

YZX:
:   YZX Euler.

    Euler using the YZX rotation order.

ZXY:
:   ZXY Euler.

    Euler using the ZXY rotation order.

ZYX:
:   ZYX Euler.

    Euler using the ZYX rotation order.

QUATERNION:
:   Quaternion.

    Quaternion rotation.

SWING_TWIST_X:
:   Swing and X Twist.

    Decompose into a swing rotation to aim the X axis, followed by twist around it.

SWING_TWIST_Y:
:   Swing and Y Twist.

    Decompose into a swing rotation to aim the Y axis, followed by twist around it.

SWING_TWIST_Z:
:   Swing and Z Twist.

    Decompose into a swing rotation to aim the Z axis, followed by twist around it.
user: Give a detailed overview of GreasePencilArmatureModifier(Modifier): syntax, arguments, return values, common patterns.

assistant: # GreasePencilArmatureModifier(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.GreasePencilArmatureModifier(*Modifier*)
:   Deform stroke points using armature object

    invert_vertex_group
    :   Invert vertex group weights

        Type:
        :   boolean, default False

    object
    :   Armature object to deform with

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

    open_influence_panel
    :   Type:
        :   boolean, default False

    use_bone_envelopes
    :   Bind Bone envelopes to armature modifier

        Type:
        :   boolean, default False

    use_deform_preserve_volume
    :   Deform rotation interpolation with quaternions

        Type:
        :   boolean, default False

    use_vertex_groups
    :   Bind vertex groups to armature modifier

        Type:
        :   boolean, default True

    vertex_group_name
    :   Vertex group name for modulating the deform

        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 Select Similar, preserving all code examples.

assistant: Children
:   Extends the selection to all hierarchical descendant bones.

Immediate Children
:   Extends the selection to all direct child bones.

Siblings
:   Selects bones that have the same parent as the active bone.

Length
:   Selects bones with a similar [bone length](properties/transform.xhtml#bpy-types-editbone-length) under the specified *Threshold*.

Direction (Y axis)
:   Select bones aligned on the Y axis (along the bone’s length).

Prefix
:   Select bones with matching name prefix (separated by `.`).

Suffix
:   Select bones with matching name suffix (separated by `.`).

Bone Collection
:   Select bones that share one or more bone collections with the active bone.

Color
:   Select bones that have the same color as the active bone.

Shape
:   Select bones using the same shape object (in Pose Mode).
user: What is Outputs and how is it used in Blender Python scripting?

assistant: For each input, the same output is added to act as a pass through.

Geometry
:   Standard geometry output, which is used as the default bake item.
    More bake items can be added by dragging sockets into the blank socket or in the *Bake Items* panel.
    Items can be renamed by `Ctrl`-`LMB` on the socket name or in the nodes *Properties* panel.
user: Describe Controls from the Blender manual or Python API, including usage steps and snippets.

assistant: Tabs
:   Click on the tabs to switch between workspaces.
    Double-click a tab to rename the workspace.

Add Workspace
:   Adds a new workspace from a predefined template (e.g. *Modeling*, *Sculpting*, *Compositing*).

Context Menu `RMB`

Duplicate
:   Makes a copy of the selected workspace, including its screen layout and editors.

Delete
:   Deletes the selected workspace.
    If it is the last workspace, it cannot be removed.

Reorder to Front/Back
:   Moves the workspace tab to the first (front) or last (back) position in the tab list.

Previous Workspace `Ctrl`-`PageUp`
:   Activates the workspace immediately to the left of the current one.

Next Workspace `Ctrl`-`PageDown`
:   Activates the workspace immediately to the right of the current one.

Delete Other Workspaces
:   Removes all workspaces except the one that was right-clicked on.
user: Explain ShaderNodeBump(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeBump(ShaderNode)

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

*class* bpy.types.ShaderNodeBump(*ShaderNode*)
:   Generate a perturbed normal from a height texture for bump mapping. Typically used for faking highly detailed surfaces

    invert
    :   Invert the bump mapping direction to push into the surface instead of out

        Type:
        :   boolean, default False

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Shear

Shearing is a form of movement where parallel surfaces move past one another. During this transform,
movement of the selected elements will occur along the horizontal axis of the current view.
The axis location will be defined by
the [Pivot Point](../../../../../editors/3dview/controls/pivot_point/index.html).
Everything that is “above” this axis will move (shear)
in the same direction as your mouse pointer (but always parallel to the horizontal axis).
Everything that is “below” the horizontal axis will move in the opposite direction.

[image reference removed]

Shear Offset Factor.
user: Describe GeometryNodeCurvePrimitiveCircle(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeCurvePrimitiveCircle(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.GeometryNodeCurvePrimitiveCircle(*GeometryNode*)
:   Generate a poly spline circle

    mode
    :   Method used to determine radius and placement

        - `POINTS`
          Points – Define the radius and location with three points.
        - `RADIUS`
          Radius – Define the radius with a float.

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Mode
:   The color model to output.

    RGB:
    :   Split the input image into it’s three outputs: Red, Green, and Blue color channels.

    HSV:
    :   Split the input image into it’s three outputs: Hue, Saturation, and Value color channels.

    HSL:
    :   Split the input image into it’s three outputs: Hue, Saturation, and Lightness color channels.

    YCbCrA:
    :   > Split the input image into it’s three outputs:
        > Luminance, Chrominance Blue, and Chrominance Red color channels.

        Color Space
        :   ITU 601, ITU 709, JPEG

    YUV:
    :   Split the input image into it’s three outputs:
        Luminance, U chrominance, and V chrominance color channels.
user: Describe Usage from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Setup for Hair Particles

1. Create a *Hair* particle system.
2. Give it an initial velocity in the *Normal* direction.
3. Create a simulation.
4. Check the *Hair Dynamics* box.

[image reference removed]

Editing hair strands in Particle Edit Mode.

### Setup for Particle, Cloth, and Soft Body Simulations

1. Use *Emitter* particles, or a cloth/soft body simulation.
2. Create a simulation by setting up objects and/or emitters,
   set your time range (use a small range if you are just starting out and experimenting),
   set up the simulation how you want it, play the animation to preview it.

### Bake the Simulation

Once you are happy with the general simulation, [bake](emitter/cache.xhtml)
the simulation from Object Mode. The simulation must be baked to enable editing.

### Edit the Simulation

Switch to *Particle Edit* from the *Mode* select menu in the header of the 3D Viewport
to edit the particle’s paths/Keyframes. You may need to press `T` from within the 3D Viewport
to see the *Particle Edit* toolbox. Move to the frame you want to edit and use the various
tools to edit your simulation.