PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with Shape Key Editor in a Blender add-on or script – include code.

assistant: # Shape Key Editor

The *Shape Key Editor* displays the [shape keys](../../../animation/shape_keys/introduction.xhtml) of the
active object and allows you to create and adjust keyframes for their
[influence values](../../../animation/shape_keys/shape_keys_panel.xhtml#bpy-types-shapekey-value).
This editor is a specialized mode of the [Dope Sheet](../introduction.xhtml),
focused specifically on shape key animation.

Each row represents a shape key, and each keyframe marker corresponds to a point where the
shape key’s value changes over time.
This provides an efficient way to time and refine facial expressions, morph targets,
and other mesh deformations driven by shape keys.

Additional shape key properties, such as names, values, and relative settings,
can be viewed and edited in the *Sidebar*.

[image reference removed]

The Shape Key Editor.
user: Show practical ways to work with Node Socket Type Items in a Blender add-on or script – include code.

assistant: # Node Socket Type Items

CUSTOM:
:   Custom.

VALUE:
:   Value.

INT:
:   Integer.

BOOLEAN:
:   Boolean.

VECTOR:
:   Vector.

ROTATION:
:   Rotation.

MATRIX:
:   Matrix.

STRING:
:   String.

RGBA:
:   RGBA.

SHADER:
:   Shader.

OBJECT:
:   Object.

IMAGE:
:   Image.

GEOMETRY:
:   Geometry.

COLLECTION:
:   Collection.

TEXTURE:
:   Texture.

MATERIAL:
:   Material.

MENU:
:   Menu.

BUNDLE:
:   Bundle.

CLOSURE:
:   Closure.
user: What is Particle Edit Mode and how is it used in Blender Python scripting?

assistant: # Particle Edit Mode

Using *Particle Edit Mode* you can edit the keyed points (keyframes)
and paths of [Hair](hair/index.html),
[Particle](index.html), [Cloth](../cloth/index.html), and
[Soft Body](../soft_body/index.html) simulations. (You can also edit and style hair before baking.)

Since working in Particle Edit Mode is pretty easy and very similar
to working with vertices in the 3D Viewport, we will show how to set up
a particle system and then give a reference of the various functions.
user: Provide the full official documentation entry for Smooth, preserving all code examples.

assistant: # Smooth

Smooths the positions of the vertices to either polish surfaces or remove volume from larger shapes.
Because this brush is so essential, it’s always accessible by holding `Shift` and sculpting.

Also available as a [Mesh Filter](../tools/mesh_filter.xhtml)
to smooth all unmasked areas at once.
user: Show practical ways to work with Spreadsheet in a Blender add-on or script – include code.

assistant: # Spreadsheet

The Spreadsheet editor is used to inspect the geometry attributes of the [active](../glossary/index.xhtml#term-Active) object,
typically in order to debug [geometry nodes](../modeling/geometry_nodes/introduction.xhtml).

[image reference removed]

The Spreadsheet editor.
user: What is PHYSICS_UL_dynapaint_surfaces(UIList) and how is it used in Blender Python scripting?

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

Edited Action panel.

Contains settings for the object’s active action. Only visible if the
[Action Track](tracks.xhtml#nla-action-track) is selected.

Action
:   A [data-block](../../interface/controls/templates/data_block.xhtml#ui-data-block) menu where you can see, change, and clear the active action.
    See also the Action Editor’s [Action](../dope_sheet/modes/action.xhtml#dopesheet-action-action).

Slot
:   The slot within the active action to use.

Extrapolation
:   Determines whether the action will influence the frames before/after its boundaries
    once it has been pushed down into a strip. (As long as it’s still the active action,
    *Hold* is used regardless of the choice.)

    Hold
    :   The property values at the action’s first keyframe also apply to the earlier frames
        (if the strip is the first in the track). The values at its last keyframe also
        apply to the later frames (up to the next strip).

    Hold Forward
    :   The property values at the action’s last keyframe also apply to the later frames
        (up to the next strip).

    Nothing
    :   The animated properties return to their default values outside of the strip boundaries.

Blending
:   How to combine the action’s property values with those of the tracks below.

    Replace
    :   Overwrites the values produced by the lower tracks. If *Influence* is less than 1,
        a linear interpolation between the previous and new values is used instead.

    Multiply, Subtract, Add
    :   Blends the action’s values with those of the lower tracks using a simple calculation.
        If *Influence* is less than 1, a linear interpolation between the previous values
        and these calculated values is used.

        \(result = mix(previous, previous (+-×) value, influence)\)

    Combine
    :   Depending on the type of each property, one of the following methods is automatically chosen:

        Axis/Angle Rotation
        :   \(result = previous + value × influence\)

            This results in averaging the axis and adding the amount of rotation.

        Quaternion Rotation
        :   Quaternion math is applied to all four channels of the property at once:

            \(result = {previous} × {value} ^ {influence}\)

        Proportional (Scale)
        :   \(result = previous × (value / default) ^ {influence}\)

        Others
        :   \(result = previous + (value - default) × {influence}\)

Influence
:   How much the action contributes to the result of the NLA stack.
user: What is References and how is it used in Blender Python scripting?

assistant: |  |  |
| --- | --- |
| - [`CurveMapping.curves`](bpy.types.CurveMapping.html#bpy.types.CurveMapping.curves "bpy.types.CurveMapping.curves") | - [`CurveMapping.evaluate`](bpy.types.CurveMapping.html#bpy.types.CurveMapping.evaluate "bpy.types.CurveMapping.evaluate") |
user: Describe BlendImportContextLibrary(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # BlendImportContextLibrary(bpy_struct)

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

*class* bpy.types.BlendImportContextLibrary(*bpy_struct*)
:   Library (blendfile) reference in a BlendImportContext data. Currently only exposed as read-only data for the pre/post blendimport handlers

    filepath
    :   Type:
        :   string, default “”, (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: Describe ShaderNodeClamp(ShaderNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShaderNodeClamp(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.ShaderNodeClamp(*ShaderNode*)
:   Clamp a value between a minimum and a maximum

    clamp_type
    :   Type:
        :   enum in [Node Clamp Items](bpy_types_enum_items/node_clamp_items.html#rna-enum-node-clamp-items), default `'MINMAX'`

    *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 PaletteColor(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # PaletteColor(bpy_struct)

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

*class* bpy.types.PaletteColor(*bpy_struct*)
:   color
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

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

    weight
    :   Type:
        :   float in [0, 1], 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: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`Curves.attributes`](bpy.types.Curves.html#bpy.types.Curves.attributes "bpy.types.Curves.attributes") | - [`Curves.color_attributes`](bpy.types.Curves.html#bpy.types.Curves.color_attributes "bpy.types.Curves.color_attributes") |
user: Describe Vertex Paint Brushes from the Blender manual or Python API, including usage steps and snippets.

assistant: # Vertex Paint Brushes

Brushes for Grease Pencil *Vertex Paint* mode bundled in the *Essentials* library.

Paint Point Color
:   Paints a specified color over the object.

Blur Point Color
:   Smooths out the colors of adjacent vertices. In this mode the Color
    Value is ignored. The strength defines how much the colors are blurred.

Average Point Color
:   Smooths color by painting the average resulting color from all colors under the brush.

Smear Point Color
:   Smudges colors by grabbing the colors under the brush and “dragging” them.
    This can be imagined as a finger painting tool.

Replace Point Color
:   Change the color only to the stroke points that already have a color applied.
user: Give a detailed overview of Armature Deform Parent: syntax, arguments, return values, common patterns.

assistant: # Armature Deform Parent

Armature Deform Parenting is a way of creating and setting up
an [Armature Modifier](../../../modeling/modifiers/deform/armature.html).

To use *Armature Deform Parenting* you must first select all the child objects that will be
influenced by the armature and then lastly, select the armature object itself.
Once all the child objects and the armature are selected, press `Ctrl`-`P` and
select *Armature Deform* in the *Set Parent To* pop-up menu.

The armature will be the parent object of all the other child objects and each child object
will have an Armature Modifier with the armature associated (*Object* field).

[image reference removed]

Bone associated with Mesh Object.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`WindowManager.popover_begin__internal`](bpy.types.WindowManager.html#bpy.types.WindowManager.popover_begin__internal "bpy.types.WindowManager.popover_begin__internal") | - [`WindowManager.popover_end__internal`](bpy.types.WindowManager.html#bpy.types.WindowManager.popover_end__internal "bpy.types.WindowManager.popover_end__internal") |
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: Simple example showing two closed edge loops.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_simple-before.png   Input. | ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_simple-after.png   Bridge result. |

Example of the Bridge tool between edge loops with different numbers of vertices.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_uneven-before.png   Input. | ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_uneven-after.png   Bridge result. |

Example using the Bridge tool to cut holes in face selections and connect them.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_faces-before.png   Input. | ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_faces-after.png   Bridge result. |

Example showing how Bridge tool can detect multiple loops and connect them in one step.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_multi-before.png   Input. | ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_multi-after.png   Bridge result. |

Example of the subdivision option and surface blending with UVs.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_advanced-before.png   Input. | ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_advanced-after.png   Bridge result. |
user: What is Generating the Set of Files for the Target Language and how is it used in Blender Python scripting?

assistant: 1. Check out the current translation repository using the command:

   ```
   git clone https://projects.blender.org/blender/blender-manual-translations.git locale
   ```

   This will download all language sets available in the repository into the `locale` directory of your drive. You
   can go to the `locale` directory to see the hidden subdirectory `.git` within it, together with directories of
   languages. You’ll need to add your own set of files for the language you are trying to translating to.
2. From the `blender-manual` directory to generate a set of files for `fr` language:

   ```
   make update_po
   ```

   These files are still in English only, with all `msgstr` entries blank.
3. Submit new set of files to the central repository:

   ```
   cd locale
   git add fr
   git commit -m "Initial commit language set of files for French"
   ```
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Mesh
:   The resulting mesh extracted from the grid’s isosurface.
    The mesh follows the region where the grid’s scalar values equal the
    specified *Threshold*, and can be used for further geometry processing or rendering.
user: Give a detailed overview of Flow: syntax, arguments, return values, common patterns.

assistant: # Flow

Fluid *Flow* types are used to add or remove fluid to a domain object. Flow objects should be
contained within the domain’s [Bounding Box](../../../glossary/index.xhtml#term-Bounding-Box) in order to work.

To define any mesh object as a *Flow* object, add Fluid physics by clicking *Fluid* in
Properties ‣ Physics. Then select *Flow* as the fluid *Type*. Now you should have
a default fluid flow source object.
user: How do I use ShaderNodeBsdfTransparent(ShaderNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ShaderNodeBsdfTransparent(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.ShaderNodeBsdfTransparent(*ShaderNode*)
:   Transparency without refraction, passing straight through the surface as if there were no geometry

    *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 ForeachGeometryElementGenerationItem(bpy_struct) in a Blender add-on or script – include code.

assistant: # ForeachGeometryElementGenerationItem(bpy_struct)

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

*class* bpy.types.ForeachGeometryElementGenerationItem(*bpy_struct*)
:   color
    :   Color of the corresponding socket type in the node editor

        Type:
        :   float array of 4 items in [0, inf], default (0.0, 0.0, 0.0, 0.0), (readonly)

    domain
    :   Domain that the field is evaluated on

        Type:
        :   enum in [Attribute Domain Items](bpy_types_enum_items/attribute_domain_items.html#rna-enum-attribute-domain-items), default `'POINT'`

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

    socket_type
    :   Type:
        :   enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items), default `'FLOAT'`

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

assistant: Language
:   The language used in the user interface. The list is broken up into categories determining how complete the
    translations are. More language preferences can be set in the
    [Translation Preferences](../../editors/preferences/interface.xhtml#prefs-interface-translation).

Theme
:   Choose between a light or dark theme for Blender. Themes can be customized more in the
    [Preferences](../../editors/preferences/themes.xhtml). Additional themes can be installed by visiting the
    [Blender Extensions Platform](https://extensions.blender.org/). This is optional, and will require internet
    access.

Keymap
:   Presets for the default [keymap](../../editors/preferences/keymap.xhtml) for Blender. Note that this manual assumes that
    you use the default “Blender” keymap.

    Blender:
    :   This is the default keymap. Read more about this keymap [here](../../interface/keymap/blender_default.xhtml).

    Blender 2.7x:
    :   This keymap is intended to match an older series of Blender versions and is designed for people upgrading who do
        not want to learn the updated keymap.

    Industry Compatible:
    :   This keymap is intended to match common commercial creation software and is intended for people who use many
        different such applications. Read more about this keymap [here](../../interface/keymap/industry_compatible.xhtml).

Mouse Select
:   Controls which mouse button, either right or left, is used to select items in Blender. The default is for selection
    to use the left button.

Spacebar Action
:   Controls the action of `Spacebar`.
    These and other shortcuts can be modified in the [keymap preferences](../../editors/preferences/keymap.xhtml).

    Play:
    :   Starts/stops [animation playback](../../animation/index.xhtml).
        This option is good for animation or video editing work.

    Tools:
    :   Opens the Toolbar underneath the cursor to quickly change the active tool. This option is good if doing a lot of
        modeling or rigging.

    Search:
    :   Opens up the [Menu Search](../../interface/operators.xhtml#bpy-ops-wm-search-menu). This option is good for someone who is new to Blender
        and is unfamiliar with its menus and shortcuts.

Save New Preferences
:   Saves the preferences set above and opens the regular [Splash Screen](../../interface/window_system/splash.xhtml#splash).
user: How do I use With Envelope Weights in Blender? Include parameters, examples, warnings and best practices.

assistant: Works in a similar way to *With Automatic Weights*. The difference is that the influences are calculated
based on the [Bone Envelopes](../bones/properties/deform.html#armature-bones-envelope) settings.
It will assign a weight to each vertex group the vertices that is inside its bone’s influence volume,
depending on their distance to this bone.

This means newly included/excluded vertices or new envelope settings will not be taken into account.
You will have to apply Armature Deform With Envelope Weights parenting again.

[image reference removed]

Two sets of armatures, each with three bones.
user: How do I use MeshLoopColor(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # MeshLoopColor(bpy_struct)

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

*class* bpy.types.MeshLoopColor(*bpy_struct*)
:   Vertex loop colors in a Mesh

    color
    :   Color in sRGB color space

        Type:
        :   float array of 4 items in [0, 1], default (0.0, 0.0, 0.0, 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: Describe Shadows from the Blender manual or Python API, including usage steps and snippets.

assistant: Rays
:   Number of rays to trace for each light.
    Higher values reduces the noise caused by random shadow sampling.

Steps
:   Number of shadow map sample per shadow ray.
    Higher step count results in softer shadows but have a higher cost.

Volumetric Shadows
:   Approximate light absorption of the surrounding volume objects. This makes the volumes more opaque to light.
    This is a very computationally expensive option and has limitations.

    Steps
    :   Number of steps to compute volumetric shadowing.

Resolution
:   Resolution percentage of shadow maps.
user: Provide the full official documentation entry for GreasePencilArmatureModifier(Modifier), preserving all code examples.

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: Give a detailed overview of BoneCollectionMemberships(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # BoneCollectionMemberships(bpy_struct)

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

*class* bpy.types.BoneCollectionMemberships(*bpy_struct*)
:   The Bone Collections that contain this Bone

    clear()
    :   Remove this bone from all bone collections

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

assistant: # MeshPolygon(bpy_struct)

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

*class* bpy.types.MeshPolygon(*bpy_struct*)
:   Polygon in a Mesh data-block

    area
    :   Read only area of this face

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

    center
    :   Center of this face

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

    hide
    :   Type:
        :   boolean, default False

    index
    :   Index of this face

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

    loop_start
    :   Index of the first loop of this face

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

    loop_total
    :   Number of loops used by this face

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

    material_index
    :   Material slot index of this face

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

    normal
    :   Local space unit length normal vector for this face

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

    select
    :   Type:
        :   boolean, default False

    use_smooth
    :   Type:
        :   boolean, default False

    vertices
    :   Vertex indices

        Type:
        :   int array of 3 items in [0, inf], default (0, 0, 0)

    edge_keys
    :   (readonly)

    loop_indices
    :   (readonly)

    flip()
    :   Invert winding of this face (flip its normal)

    *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 FunctionNodeInputVector(FunctionNode) in a Blender add-on or script – include code.

assistant: # FunctionNodeInputVector(FunctionNode)

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

*class* bpy.types.FunctionNodeInputVector(*FunctionNode*)
:   Provide a vector value that can be connected to other nodes in the tree

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

Here, the selection outputs are used to set materials on certain faces of the mesh.
A [Random Value Node](../../utilities/random_value.html) is used to limit the
extrusion to a random set of faces.
user: How do I use XrActionMap(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # XrActionMap(bpy_struct)

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

*class* bpy.types.XrActionMap(*bpy_struct*)
:   actionmap_items
    :   Items in the action map, mapping an XR event to an operator, pose, or haptic output

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

    name
    :   Name of the action map

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

    selected_item
    :   Type:
        :   int in [-32768, 32767], 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: Explain Lattice in complete detail according to the official Blender documentation.

assistant: # Lattice

Lattice – or commonly called deformation cage outside of Blender.
A lattice consists of a three-dimensional non-renderable grid of vertices.
Its main use is to apply a deformation to the object it controls with a [Lattice Modifier](../modeling/modifiers/deform/lattice.xhtml).
If the object is parented with *Lattice Deform* a Lattice Modifier is automatically applied.
user: Give a detailed overview of Armature Structure: syntax, arguments, return values, common patterns.

assistant: # Armature Structure

[image reference removed]

Example of a very basic armature.

Armatures mimic real skeletons. They are made out of bones, which are (by default) rigid elements.
But you have more possibilities than with real skeletons: In addition to the “natural” rotation of bones,
you can also move and even scale them! And your bones do not have to be connected to each other;
they can be completely free if you want. However,
the most natural and useful setups imply that some bones are related to others, forming so-called “chains of bones”,
which create some sort of “limbs” in your armature, as detailed in [Chains of Bones](#chains-of-bones).
user: Show practical ways to work with Common Examples in a Blender add-on or script – include code.

assistant: Below are a few common kernels and their uses:

### Blur

A simple blur can be achieved with evenly weighted positive values.
For example, a 3x3 average blur kernel:

```
1/9  1/9  1/9
1/9  1/9  1/9
1/9  1/9  1/9
```

This softens the image by averaging neighboring pixels.

### Sharpen

A sharpening kernel enhances contrast at edges by emphasizing differences
between the center pixel and its neighbors:

```
 0  -1   0
-1   5  -1
 0  -1   0
```

### Edge Detection

Edge detection kernels highlight transitions in brightness by measuring differences between
adjacent pixels.
For example, the *Laplacian* kernel:

```
 0  -1   0
-1   4  -1
 0  -1   0
```

Or the *Sobel* kernel (horizontal edges):

```
-1  -2  -1
 0   0   0
 1   2   1
```
user: Show practical ways to work with Constraints in a Blender add-on or script – include code.

assistant: When moving, rotating or scaling, if you only want certain axes to be affected,
you can restrict the transformation to those axes.

By default the constraint keys are `X`, `Y` and `Z`.
This constraint can be restricted to a plane if `Shift`
is pressed or automatically detected if `MMB` is pressed.

It is worth noting that if you press the same constraint hotkey a second time,
you change the orientation from Local to Global or vice versa. Pressing a third time disables the constraint.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

Export options.

All UVs
:   Export all UVs rather than only what is selected in the 3D View.

Export Tiles
:   Choose whether to export only the [0,1] range, or all UV tiles

Modified
:   Export UVs from the mesh with all its modifiers evaluated.

Format
:   Image file format to save to (`.png`, `.eps`, `.svg`).

Size
:   The size of the exported image in pixels.

Fill Opacity
:   Set the opacity of the fill.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Data Type
:   The data type that is used for mixing.
    The node supports float, vector, color, and rotation data types.

Factor Mode (Vector only)
:   The factor mode can be set to *Uniform* and *Non-Uniform*.
    In uniform mode, a single float controls the factor.
    In non-uniform mode, a vector controls the factor for
    each XYZ channel separately.

Mix (Color only)
:   The Blend modes can be selected in the select menu.
    See [Color Blend Modes](../../../glossary/index.xhtml#term-Color-Blend-Modes) for details on each blending mode.

    Add, Subtract, Multiply, Screen, Divide, Difference,
    Darken, Lighten, Overlay, Color Dodge, Color Burn,
    Hue, Saturation, Value, Color, Soft Light, Linear Light

Clamp Factor
:   Limit the factor value between 0.0 and 1.0. If this option is
    unchecked then the node operates using *Extrapolation*.

Clamp Result (Color only)
:   Limit the Result to the range between 0.0 and 1.0.
user: Provide the full official documentation entry for Asset Types, preserving all code examples.

assistant: Assets can be broadly divided into two types: **primitive** and **preset** assets.
Which is which depends on the [Data-Blocks](../data_blocks.xhtml) type.

Primitive assets are data-blocks that are either **linked or appended** to the current file.
Examples are objects, materials, and worlds. These can be dragged from the Asset Browser into
the scene (objects and worlds), or onto existing objects (materials).

Preset assets are data-blocks that are loaded and then **applied** to something or **activated**.
An example is a pose asset. When applying the pose, the data-block is loaded from its blend-file,
and then the pose is applied to the active armature. Brush assets are an example of an asset type
that is activated. They get loaded into the current file and activated for painting or sculpting,
but don’t get saved in the file.

In the future, the asset type definition will be expanded;
see [Future Development](#asset-libraries-future-development) for more info.

### Supported Assets

| Asset | Type | Description |
| --- | --- | --- |
| Material | Primitive | A [Material](../../render/materials/index.xhtml) data-block that can be applied to objects. When dragged onto an object, it replaces the material slot. |
| Collection | Primitive | A [Collection](../../scene_layout/collections/index.xhtml) is a group of objects that can be linked or appended into a scene. Collections maintain their internal hierarchy and can be instanced or used for modular scene composition. |
| Object | Primitive | A standard [Object](../../scene_layout/object/index.xhtml) asset that can be dragged into the scene. It may contain mesh, curve, light, or other data. |
| Brush | Preset | A [Brush](../../sculpt_paint/brush/index.xhtml) asset used for sculpting, texture painting, or vertex painting. When activated, it becomes the current brush but is not stored permanently in the file. |
| Node Group | Primitive | A [Node Group](../../interface/controls/nodes/groups.xhtml) asset that can be dragged into compatible node editors such as Geometry Nodes, Shader Editor, or Compositor. Acts as a reusable building block of node logic. |
| World | Primitive | A [World](../../render/lights/world.xhtml) asset defining ambient lighting and background. When dragged into the viewport, it replaces the current world. It can also be appended as a data-block. |
| Scene | Primitive | A full [Scene](../../scene_layout/scene/index.xhtml) asset, including its cameras, lights, and linked objects.   - Scenes generate previews by rendering the active camera view in Solid mode.   This requires the scene to have an active camera. - Dragging a scene asset into a window (except the Asset Browser itself)   imports or links the scene and makes it the active scene in that window. |
| Pose Action | Preset | A [Pose Asset](../../animation/armatures/posing/editing/pose_library.xhtml) based on an Action data-block. Applying it loads the pose data and applies it to the selected or active armature, updating bone transforms without permanently modifying the source action. |
user: Provide the full official documentation entry for Examples, preserving all code examples.

assistant: Simple example showing two closed edge loops.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_simple-before.png   Input. | ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_simple-after.png   Bridge result. |

Example of the Bridge tool between edge loops with different numbers of vertices.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_uneven-before.png   Input. | ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_uneven-after.png   Bridge result. |

Example using the Bridge tool to cut holes in face selections and connect them.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_faces-before.png   Input. | ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_faces-after.png   Bridge result. |

Example showing how Bridge tool can detect multiple loops and connect them in one step.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_multi-before.png   Input. | ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_multi-after.png   Bridge result. |

Example of the subdivision option and surface blending with UVs.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_advanced-before.png   Input. | ../../../../_images/modeling_meshes_editing_edge_bridge-edge-loops_advanced-after.png   Bridge result. |
user: Provide the full official documentation entry for Nodes, preserving all code examples.

assistant: Nodes should always have three headings inputs, properties and outputs with a note of absence if the node has none. At
the end of the page can be an optional example(s) section:

```
**********
World Node
**********

.. figure:: /images/render_shader-nodes_output_world_node.png
   :align: right

   The World node.

Introduction and general use case(s).

Inputs
======

This node has no inputs.

Properties
==========

This node has no properties.

Outputs
=======

This node has no outputs.

Example
=======
```
user: Give a detailed overview of Transform Panel: syntax, arguments, return values, common patterns.

assistant: When nothing is selected, the panel is empty.
When more than one vertex is selected, the median values is edited
and “Median” is added in front of the labels.

Vertex
:   The first controls (X, Y, Z) show the coordinates of the selected vertex or the median point.

Space
:   The Space radio buttons let you choose if those coordinates are relative to the object origin (local) or
    the global origin (global).

    Global, Local

### Vertex Data

Bevel Weight
:   This vertex property, a value between (0.0 to 1.0),
    is used by the [Bevel Modifier](../../../../modifiers/generate/bevel.xhtml)
    to control the bevel intensity of the vertices, when the *Only Vertices* option is active.

Crease
:   This vertex property, a value between (0.0 to 1.0), is used by
    the [Subdivision Surface Modifier](../../../../modifiers/generate/subdivision_surface.xhtml)
    to control the sharpness of the vertices in the subdivided mesh.

### Edge Data

When an edge is selected, the following options are available. More buttons appear:

Bevel Weight
:   This edge property, a value between (0.0 to 1.0),
    is used by the [Bevel Modifier](../../../../modifiers/generate/bevel.xhtml)
    to control the bevel intensity of the edges.

    This property can also be set using the [Edge Bevel Weight](../../edge/edge_data.xhtml#bpy-ops-transform-edge-bevelweight) operator.

Crease
:   This edge property, a value between (0.0 to 1.0), is used by
    the [Subdivision Surface Modifier](../../../../modifiers/generate/subdivision_surface.xhtml)
    to control the sharpness of the edges in the subdivided mesh.
user: Describe What is an Add-on? from the Blender manual or Python API, including usage steps and snippets.

assistant: An add-on is simply a Python module with some additional requirements so Blender
can display it in a list with useful information.

To give an example, here is the simplest possible add-on:

```
bl_info = {
    "name": "My Test Add-on",
    "blender": (2, 80, 0),
    "category": "Object",
}
def register():
    print("Hello World")
def unregister():
    print("Goodbye World")
```

`bl_info`
:   is a dictionary containing add-on metadata such as the title,
    version and author to be displayed in the Preferences add-on list.
    It also specifies the minimum Blender version required to run the script;
    older versions won’t display the add-on in the list.

`register`
:   is a function which only runs when enabling the add-on,
    this means the module can be loaded without activating the add-on.

`unregister`
:   is a function to unload anything setup by `register`,
    this is called when the add-on is disabled.

Notice this add-on does not do anything related to Blender
(the `blender_api:bpy` module is not imported for example).

This is a contrived example of an add-on that serves to illustrate the point
that the base requirements of an add-on are simple.

An add-on will typically register operators, panels, menu items, etc,
but it’s worth noting that *any* script can do this,
when executed from the Text editor or even the interactive console –
there is nothing inherently different about an add-on that allows it to integrate with Blender,
such functionality is just provided by the `blender_api:bpy` module for any script to access.

So an add-on is just a way to encapsulate a Python module in a way a user can easily utilize.