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

assistant: [image reference removed]

Keyed Physics settings.

Loops
:   Sets the number of times the entire *Keys* list is repeated. Disabled if *Use Timing* is enabled.

Use Timing
:   Enabling this option allows you to specify the timing for each key independently,
    using the *Time* and *Duration* options.
    By default, the *Use Timing* option is deactivated, and the particles will pass through all keys
    for a time equal to its lifetime. A shorter lifetime means faster movement.
    The lifetime will be split equally between the keys,
    this may lead to varying particle speeds between the targets.
user: Give a detailed overview of Knife Project: syntax, arguments, return values, common patterns.

assistant: # Knife Project

Knife Project is a non-interactive tool where you can use objects to cookie-cut into
one or more meshes rather than hand drawing the line. The outline of the selected objects
that *are not* in Edit Mode is projected along the view axis onto the meshes that *are*
in Edit Mode, and then cuts into the faces there. Afterwards, the resulting geometry
inside the cut gets selected.

Keep in mind that Knife Project works from the current view’s perspective. For best results, make sure
to rotate your view to exactly the position you require before using this tool. Orthographic views such
as Right, Front, and Top are commonly used for this.

To use Knife Project, select the objects to be cut, switch to *Edit Mode*,
select the cutting objects in the Outliner (`Ctrl`-`LMB`),
and choose Mesh ‣ Knife Project.

If Blender switches back to *Object Mode* when selecting the cutting objects,
make sure that Edit ‣ Lock Object Modes is checked in the topbar.
Alternatively, if you have only one cutting object, you can select it in the
viewport with `Ctrl`-`LMB`.
user: Describe Color Tagging from the Blender manual or Python API, including usage steps and snippets.

assistant: Collections can have a color group assigned to them; helping organize
and group different collections. This color tag is displayed as part of
the collection icon in the [Outliner](../../editors/outliner/index.html)
and various other menus. The available colors are defined by
Blender’s interface [Theme](../../editors/preferences/themes.html).

To assign a color to a collection,
use the [Set Color Tag](../../editors/outliner/editing.html#bpy-ops-outliner-collection-color-tag-set) tool in the Outliner.
user: Give a detailed overview of Pivot Point: syntax, arguments, return values, common patterns.

assistant: # Pivot Point

The Pivot Point is the point around which images are rotated and scaled.
It’s indicated by the position of the selected tool’s gizmo.

Bounding Box Center ()
:   Use the center of the rectangle that’s wrapped as tightly as possible around the selected
    images’ origin points.

Median Point ()
:   Use the averaged-out position of the selected images’ origin points.

2D Cursor ()
:   Use the location of the [2D Cursor](../sidebar.xhtml#editors-sequencer-preview-2d-cursor),
    for when you want to specify the pivot point by hand.

Individual Origins ()
:   Rotate/scale each image around its own origin, rather than rotating/scaling
    all of them around the same single point like the other options do.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`EffectStrip.transform`](bpy.types.EffectStrip.html#bpy.types.EffectStrip.transform "bpy.types.EffectStrip.transform") - [`ImageStrip.transform`](bpy.types.ImageStrip.html#bpy.types.ImageStrip.transform "bpy.types.ImageStrip.transform") - [`MaskStrip.transform`](bpy.types.MaskStrip.html#bpy.types.MaskStrip.transform "bpy.types.MaskStrip.transform") - [`MetaStrip.transform`](bpy.types.MetaStrip.html#bpy.types.MetaStrip.transform "bpy.types.MetaStrip.transform") | - [`MovieClipStrip.transform`](bpy.types.MovieClipStrip.html#bpy.types.MovieClipStrip.transform "bpy.types.MovieClipStrip.transform") - [`MovieStrip.transform`](bpy.types.MovieStrip.html#bpy.types.MovieStrip.transform "bpy.types.MovieStrip.transform") - [`SceneStrip.transform`](bpy.types.SceneStrip.html#bpy.types.SceneStrip.transform "bpy.types.SceneStrip.transform") |
user: Describe Persistent Handler Example from the Blender manual or Python API, including usage steps and snippets.

assistant: By default handlers are freed when loading new files, in some cases you may
want the handler stay running across multiple files (when the handler is
part of an add-on for example).

For this the [`bpy.app.handlers.persistent`](#bpy.app.handlers.persistent "bpy.app.handlers.persistent") decorator needs to be used.

```
import bpy
from bpy.app.handlers import persistent

@persistent
def load_handler(dummy):
    print("Load Handler:", bpy.data.filepath)

bpy.app.handlers.load_post.append(load_handler)
```
user: What is Brush Settings and how is it used in Blender Python scripting?

assistant: ### General

### Unique

Magnify
:   Pulled geometry tends to lose volume along the stroke.
    With *Magnify* value greater than 0.5 this is prevented.
    More info at [Pinch/Magnify](../../brush/brush_settings.xhtml#bpy-types-brush-crease-pinch-factor)

Rake
:   Rotates geometry along the direction of the stroke.

Deformation
:   Deformation type that is used by the brush.

    Radius Falloff:
    :   Applies the brush falloff to the tip of the brush.

    Elastic:
    :   Modifies the entire mesh using an [Elastic](../../../glossary/index.xhtml#term-Elastic) deformation.
        More info in the [Elastic Deform](elastic_deform.xhtml) brush.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

The Vertex Weight Proximity modifier panel.

Vertex Group
:   The vertex group to affect.

    Invert
    :   Inverts the influence of the selected vertex group. The setting reverses the weight values of the group.

Target Object
:   The object from which to compute distances.

Lowest
:   Distance mapping to 0.0 weight.

Highest
:   Distance mapping to 1.0 weight.

Minimum
:   Minimum value for vertex weight.

Multiply Weights
:   Multiply the calculated weights with the existing values in the vertex group.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Provide the full official documentation entry for Map UV Node, preserving all code examples.

assistant: # Map UV Node

[image reference removed]

Map a texture using UV coordinates, to apply a texture to objects in compositing.

May be used in combination with the [Cryptomatte Node](../mask/cryptomatte.xhtml)
to only apply the texture to specific objects.
user: Explain Unsharp Mask Node in complete detail according to the official Blender documentation.

assistant: # Unsharp Mask Node

[image reference removed]

The *Unsharp Mask* node enhances the apparent sharpness of an image by increasing edge contrast.
Despite its name, it does not blur the image; instead, it sharpens details by subtracting a
blurred (unsharp) version of the image from the original and emphasizing the resulting edges.

This technique is commonly used in photography, printing, and digital compositing
to improve clarity and definition.
user: Give a detailed overview of Inherited Properties: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleColorModifier.name`](bpy.types.LineStyleColorModifier.html#bpy.types.LineStyleColorModifier.name "bpy.types.LineStyleColorModifier.name") |
user: What is SoftBodyModifier(Modifier) and how is it used in Blender Python scripting?

assistant: # SoftBodyModifier(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.SoftBodyModifier(*Modifier*)
:   Soft body simulation modifier

    point_cache
    :   Type:
        :   [`PointCache`](bpy.types.PointCache.html#bpy.types.PointCache "bpy.types.PointCache"), (readonly, never None)

    settings
    :   Type:
        :   [`SoftBodySettings`](bpy.types.SoftBodySettings.html#bpy.types.SoftBodySettings "bpy.types.SoftBodySettings"), (readonly, never None)

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Startup

If Blender fails to start, there are a few common causes to check for:

- See if your computer meets the [minimum requirements](https://www.blender.org/download/requirements/).
- Confirm that your graphics card is supported and that the drivers are up to date (see
  [Troubleshooting Graphics Hardware](gpu/index.html)).
- Make sure any antivirus software is not preventing Blender from starting.
- Ensure that you have appropriate user permissions on the computer.

If you cannot find a solution to your problem here, try asking the [community](../getting_started/about/community.html)
for help.
user: Explain Examples in complete detail according to the official Blender documentation.

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

[image reference removed]

Overlaying a grid texture.

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

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

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

[image reference removed]

Overlaying a logo.

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

[image reference removed]

Procedural distortion.
user: How do I use GeometryNodeSelfObject(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeSelfObject(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.GeometryNodeSelfObject(*GeometryNode*)
:   Retrieve the object that contains the geometry nodes modifier currently being executed

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain CurveMapPoints(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # CurveMapPoints(bpy_struct)

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

*class* bpy.types.CurveMapPoints(*bpy_struct*)
:   Collection of Curve Map Points

    new(*position*, *value*)
    :   Add point to CurveMap

        Parameters:
        :   - **position** (*float in* *[**-inf**,* *inf**]*) – Position, Position to add point
            - **value** (*float in* *[**-inf**,* *inf**]*) – Value, Value of point

        Returns:
        :   New point

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

    remove(*point*)
    :   Delete point from CurveMap

        Parameters:
        :   **point** ([`CurveMapPoint`](bpy.types.CurveMapPoint.html#bpy.types.CurveMapPoint "bpy.types.CurveMapPoint"), (never None)) – PointElement to remove

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Select all tracks from specified group.

Action
:   The group of tracks to select.

    Keyframed Tracks:
    :   Select all keyframed tracks.

    Estimated Tracks:
    :   Select all estimated tracks.

    Tracked Tracks:
    :   Select all tracked tracks.

    Locked Tracks:
    :   Select all locked tracks.

    Disabled Tracks:
    :   Select all disabled tracks.

    Track with Same Color:
    :   Select all tracks with same color as active track.

    Failed Tracks:
    :   Select all tracks which failed to be reconstructed.
user: Describe VolumeDisplaceModifier(Modifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # VolumeDisplaceModifier(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.VolumeDisplaceModifier(*Modifier*)
:   strength
    :   Strength of the displacement

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

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

    texture_map_mode
    :   - `LOCAL`
          Local – Use the local coordinate system for the texture coordinates.
        - `GLOBAL`
          Global – Use the global coordinate system for the texture coordinates.
        - `OBJECT`
          Object – Use the linked object’s local coordinate system for the texture coordinates.

        Type:
        :   enum in [`'LOCAL'`, `'GLOBAL'`, `'OBJECT'`], default `'LOCAL'`

    texture_map_object
    :   Object to use for texture mapping

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

    texture_mid_level
    :   Subtracted from the texture color to get a displacement vector

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

    texture_sample_radius
    :   Smaller values result in better performance but might cut off the volume

        Type:
        :   float in [0, inf], 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: What is Extrude Manifold and how is it used in Blender Python scripting?

assistant: # Extrude Manifold

This tool is very similar to [Extrude Faces](../editing/face/extrude_faces.xhtml)
but enables *Dissolve Orthogonal Edges* by default.
This causes the tool to automatically split and remove adjacent faces when extruding inwards.
user: Describe Scene Setup from the Blender manual or Python API, including usage steps and snippets.

assistant: Set as Background
:   See [Set as Background](../editing/clip.xhtml#bpy-ops-clip-set-viewport-background).

Setup Tracking Scene
:   See [Setup Tracking Scene](../editing/clip.xhtml#bpy-ops-clip-setup-tracking-scene).
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`Camera.background_images`](bpy.types.Camera.html#bpy.types.Camera.background_images "bpy.types.Camera.background_images") - [`CameraBackgroundImages.new`](bpy.types.CameraBackgroundImages.html#bpy.types.CameraBackgroundImages.new "bpy.types.CameraBackgroundImages.new") | - [`CameraBackgroundImages.remove`](bpy.types.CameraBackgroundImages.html#bpy.types.CameraBackgroundImages.remove "bpy.types.CameraBackgroundImages.remove") |
user: Give a detailed overview of System Directories: syntax, arguments, return values, common patterns.

assistant: System directories store files that come bundled with Blender and
are required for it to function. This includes scripts, presets, essential
assets and more.

### Linux

Archive downloaded from blender.org:

```
./5.0/
```

Linux distribution packages:

```
/usr/share/blender/5.0/
```

### macOS

```
./Blender.app/Contents/Resources/5.0/
```

### Windows

Zip file downloaded from blender.org:

```
./5.0/
```

Installer downloaded from blender.org:

```
%ProgramFiles%\Blender Foundation\Blender\5.0\
```

Microsoft Store installation:

```
%ProgramFiles%\WindowsApps\BlenderFoundation.Blender<HASH>\Blender\5.0\
```

### Environment Variables

`BLENDER_SYSTEM_SCRIPTS` and `BLENDER_SYSTEM_EXTENSIONS`
[environment variables](command_line/arguments.xhtml#command-line-args-environment-variables)
can be used to [bundle additional scripts and extensions](deploying_blender.xhtml#deploying-blender-bundling),
that are not part of the regular Blender installation.

Other `BLENDER_SYSTEM` environment variables can override other system paths,
though are not commonly used in practice.
user: Provide the full official documentation entry for What is an Asset Library?, preserving all code examples.

assistant: An asset library is a directory on your drive that is registered in the Preferences as an asset library.
Registering it means that you give the library a name (like “Sprite Fright”)
and the location on drive (like `/home/sybren/projects/sprite-fright/assets`).

[image reference removed]

Name and Location of asset libraries in the Preferences.

Once registered, you can select the asset library in the Asset Browser.
All the blend-files in the asset library will be scanned for assets,
and all those assets will be shown in the Asset Browser.

The blend-files can be directly in the top-level directory of the asset library, or in any subdirectory.
The on-drive organization of asset libraries is all up to you. Regardless of which blend-file contains the assets,
each asset can be assigned a **catalog**. For more info about how to organize your assets
this way, see [Asset Catalogs](catalogs.xhtml).
user: Show practical ways to work with Visibility in a Blender add-on or script – include code.

assistant: Use Light
:   Enables the Grease Pencil object to be affected by lights.

    This property affect the whole object, for more control with lights you can enable or disable
    the use of lights by layers. See [Layers](layers.xhtml) for more information.

    [image reference removed]

    Lights disabled (left) and enabled (right).
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`Mesh.uv_layer_clone`](bpy.types.Mesh.html#bpy.types.Mesh.uv_layer_clone "bpy.types.Mesh.uv_layer_clone") - [`Mesh.uv_layer_stencil`](bpy.types.Mesh.html#bpy.types.Mesh.uv_layer_stencil "bpy.types.Mesh.uv_layer_stencil") - [`Mesh.uv_layers`](bpy.types.Mesh.html#bpy.types.Mesh.uv_layers "bpy.types.Mesh.uv_layers") | - [`UVLoopLayers.active`](bpy.types.UVLoopLayers.html#bpy.types.UVLoopLayers.active "bpy.types.UVLoopLayers.active") - [`UVLoopLayers.new`](bpy.types.UVLoopLayers.html#bpy.types.UVLoopLayers.new "bpy.types.UVLoopLayers.new") - [`UVLoopLayers.remove`](bpy.types.UVLoopLayers.html#bpy.types.UVLoopLayers.remove "bpy.types.UVLoopLayers.remove") |
user: Describe ActionLayer(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ActionLayer(bpy_struct)

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

*class* bpy.types.ActionLayer(*bpy_struct*)
:   name
    :   Type:
        :   string, default “”, (never None)

    strips
    :   The list of strips that are on this animation layer

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [Adjust Last Operation](../undo_redo.xhtml#bpy-ops-screen-redo-last) is a region that allows
tweaking an operator after running it. For example, if you just added a cube,
you can use this region to tweak its size.
user: How do I use Feature Sets in Blender? Include parameters, examples, warnings and best practices.

assistant: # Feature Sets

Rigify allows third party developers to implement sub-addons, called *Feature Sets*,
which can provide new [Meta-Rigs](metarigs.xhtml) and
[Rig Types](rig_types/index.xhtml). Similar to regular add-ons,
they can be installed from zip-files through Rigify settings.

These are some examples of *Feature Sets* currently provided by past and current Rigify developers:

[Cessen’s Rigify Extensions](https://github.com/cessen/cessen_rigify_ext)
:   This feature set provides the original Rigify rigs by Nathan Vegdahl, minimally ported
    and repackaged to work without switching Rigify to legacy mode. Note that their names
    were changed, so meta-rigs designed for legacy mode aren’t directly compatible.

[Experimental Rigs by Alexander Gavrilov](https://github.com/angavrilov/angavrilov-rigs)
:   Rig experiments, some of which might be included in Rigify in the future. Examples include
    limbs with an extra IK system based at knee/elbow, a spline based tentacle, and more.

You can install these packages by clicking Code ‣ Download ZIP,
and then install the downloaded file through Rigify settings.

Developer documentation is available on the [Blender Developer Documentation](https://developer.blender.org/docs/features/animation/rigify/).
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

Maintain Volume constraint.

Mode
:   Specifies how the constraint handles scaling of the non-free axes.

    Strict:
    :   Adjusts the scales of the non-free axes so that the volume is always exactly maintained.
        Scaling up the free axis will scale down both non-free axes. Scaling up a non-free axis
        will scale down the other non-free axis.

    Uniform:
    :   Unlike *Strict*, this mode only maintains the volume correctly as long as the object
        is scaled equally along all three axes.

        Scaling up the free axis alone will also scale down the non-free axes, but
        in an exaggerated manner that results in a loss of volume. As such, this is
        not recommended.

        Scaling up a non-free axis has no effect on the other non-free axis. This
        makes it possible to deviate from the target volume.

    Single Axis:
    :   Similar to *Uniform*, except the mode only maintains the volume correctly as long
        as the object is scaled purely along the free axis. Because only one axis needs to
        be adjusted to keep the volume instead of three, this may reduce the number of
        animation curves needed.

        Changing the scale of a non-free axis again has no effect on the other non-free axis.

Free Axis
:   The axis that should keep its user-specified scale. The other two (non-free) axes will
    be adjusted to maintain the volume.

Volume
:   The target volume as a ratio of the original volume (when all axes have a scale of 1).

    If all three axes have a default scale of 2 and this should be maintained, *Volume* should
    be set to 2×2×2 = 8.

[Owner](../interface/common.xhtml#rigging-constraints-interface-common-space)
:   The space for determining and adjusting the scale of the owner.

[Influence](../interface/common.xhtml#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: Provide the full official documentation entry for Vortex, preserving all code examples.

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

assistant: Color
:   Color of the surface, or physically speaking, the probability that light is transmitted for each wavelength.

Roughness
:   Influences sharpness of the refraction; perfectly sharp at 0.0 and smoother with higher values.

IOR
:   Index of refraction ([IOR](../../../glossary/index.xhtml#term-IOR)) defining how much the ray changes direction. At 1.
    0 rays pass straight through like transparent; higher values give more refraction.

Normal
:   Normal used for shading.

### Thin Film Cycles Only

Thin Film simulates the effect of interference in a thin film sitting on top of the material.
This causes the specular reflection to be colored in a way which strongly depends on the view
angle as well as the film thickness and the index of refraction ([IOR](../../../glossary/index.xhtml#term-IOR)) of the film and
the material itself.

This effect is commonly seen on e.g. oil films, soap bubbles or glass coatings. While its
influence is more obvious in specular highlights, it also affects transmission.

Thickness
:   The thickness of the film in nanometers. A value of 0 disables the simulation.
    The interference effect is strongest between roughly 100 and 1000 nanometers, since this is
    near the wavelengths of visible light.

IOR
:   Index of refraction ([IOR](../../../glossary/index.xhtml#term-IOR)) of the thin film.
    The common range for this value is between 1.0 (vacuum and air) and roughly 2.0,
    though some materials can reach higher values.
    The default value of 1.33 is a good approximation for water.
    Note that when the value is set to 1.0 or to the main IOR of the material, the thin film
    effect disappears since the film optically blends into the air or the material.
user: What is Panels and how is it used in Blender Python scripting?

assistant: Panels should be documented by their own heading, nested panels should use decreasing heading levels. Each panel could
have its own page based on the length of documentation and/or the amount of panels. Expanded menus that toggle what
properties are presented to the user should be treated like subpanels:

```
Panel Title
===========

Nested Panel Title
------------------
```
user: Explain Erase Brushes in complete detail according to the official Blender documentation.

assistant: Erase brushes are the special types of brushes that uses Grease Pencil for *Erase* tools.
The brush can be changed in the Tool Settings.
Soft and hard eraser brushes are settings variations of the same *Erase Brush*.
You can create many brushes, each with unique settings to get different effects while erasing.
The *Erase Brush* has also other two special eraser types: point and stroke.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`GreasePencilFrames.copy`](bpy.types.GreasePencilFrames.html#bpy.types.GreasePencilFrames.copy "bpy.types.GreasePencilFrames.copy") - [`GreasePencilFrames.move`](bpy.types.GreasePencilFrames.html#bpy.types.GreasePencilFrames.move "bpy.types.GreasePencilFrames.move") - [`GreasePencilFrames.new`](bpy.types.GreasePencilFrames.html#bpy.types.GreasePencilFrames.new "bpy.types.GreasePencilFrames.new") | - [`GreasePencilLayer.current_frame`](bpy.types.GreasePencilLayer.html#bpy.types.GreasePencilLayer.current_frame "bpy.types.GreasePencilLayer.current_frame") - [`GreasePencilLayer.frames`](bpy.types.GreasePencilLayer.html#bpy.types.GreasePencilLayer.frames "bpy.types.GreasePencilLayer.frames") - [`GreasePencilLayer.get_frame_at`](bpy.types.GreasePencilLayer.html#bpy.types.GreasePencilLayer.get_frame_at "bpy.types.GreasePencilLayer.get_frame_at") |
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

Screw panel (in Edit Mode).

Steps
:   The number of extrusions to be done for each 360° turn.

Turns
:   The number of turns to create.

Center X, Y, Z
:   The world space coordinates of the centerpoint around which to spin the geometry.
    Initially this is the location of the 3D Cursor.

Axis X, Y, Z
:   The direction vector around which to spin the geometry.
    Initially this is the screen-space vertical axis (so the global Z axis when in a
    side view or the global Y axis when in top view). By inverting the *Axis*,
    you can flip between going clockwise and counterclockwise.

Notice that the *Axis* only determines how the geometry spins “horizontally” around
the centerpoint. It doesn’t determine how the geometry moves “vertically.”
Instead, the geometry always moves by a distance and direction given by the endpoints
of the open profile, and goes downward in the object’s local space.
user: Describe GreasePencilLayerGroup(GreasePencilTreeNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GreasePencilLayerGroup(GreasePencilTreeNode)

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

*class* bpy.types.GreasePencilLayerGroup(*GreasePencilTreeNode*)
:   Group of Grease Pencil layers

    color_tag
    :   Type:
        :   enum in [`'NONE'`, `'COLOR1'`, `'COLOR2'`, `'COLOR3'`, `'COLOR4'`, `'COLOR5'`, `'COLOR6'`, `'COLOR7'`, `'COLOR8'`], default `'COLOR1'`

    is_expanded
    :   The layer group is expanded in the UI

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Attributes, preserving all code examples.

assistant: When merging attributes from multiple geometry inputs, the highest complexity data type is chosen
for the output attribute. For example, if a `weight` attribute is a Boolean on one geometry input
and a vector on another, the `weight` attribute on the output geometry will use the vector data type.

Named and anonymous attributes are propagated from the [instance domain](../attributes_reference.xhtml#attribute-domains)
to the realized geometry. If an attribute exists both on the base geometry and on an instance,
the attribute values from the base geometry take precedence.
user: How do I use Attribute Data Types in Blender? Include parameters, examples, warnings and best practices.

assistant: The type of an attribute is the kind of data stored at each element.

Float:
:   Single floating-point value, commonly used for weights or intensity values.

Boolean:
:   True or false value for binary conditions.

Integer:
:   32-bit integer, used for indices or discrete values.

Vector:
:   3D vector with floating-point values, often representing directions or positions.

Color:
:   RGBA color with 32-bit floating-point values, stored in linear [Color Space](../../glossary/index.html#term-Color-Space)
    Suitable for high dynamic range and wide-gamut colors.

Byte Color:
:   RGBA color with 8-bit positive integer values, useful for compact color storage.
    These are always stored in the sRGB [Color Space](../../glossary/index.html#term-Color-Space).
    For wide gamut or linear workflows, use the *Color* type instead.

String:
:   Text string for storing names or labels.

2D Vector:
:   2D vector with floating-point values, often used for UV coordinates.

8-Bit Integer:
:   Small integer with a range from -128 to 127.

2D 16-Bit Integer Vector:
:   Signed 16-bit 2D vector for compact storage of integer pairs.

2D Integer Vector:
:   Signed 32-bit 2D vector.

Quaternion:
:   Floating-point [Quaternion](../../glossary/index.html#term-Quaternion) rotation used in 3D transformations.

4x4 Matrix:
:   Floating-point matrix used for transformations or storing spatial relationships.

The above list is in the order of least to most “complex” (An integer can contain more data than a
boolean, so it is more complicated). When joining separate geometries together, the more complex data
type is preferred when there are matching names. This is particularly important when joining geometry
with named attributes with the [Join Geometry Node](geometry/join_geometry.html).

To store 2D Vectors (UV maps) and Byte Colors the
[Store Named Attribute Node](attribute/store_named_attribute.html) must be
used because there are no sockets for those types.

### Data Conversion

Through the use of Geometry Nodes, data can be converted between types.

Valid conversions:

- Between color and vector – mapping between color channels and vector components.
- Between color and float – the color data is converted to its grayscale equivalent.
- Between float and integer – integers simply become floats, floats are truncated.
- Between float and vector – when a float becomes a vector the value is used for each component.
  When a vector becomes a float the average of the components is taken.
- Between float and boolean – values greater than 0 are true, true maps to 1, and false maps to 0.
user: Show practical ways to work with Custom Properties in a Blender add-on or script – include code.

assistant: Create and manage your own properties to store data in the action’s data block.
See the [Custom Properties](../../files/custom_properties.html#files-data-blocks-custom-properties) page for more information.
user: How do I use Spline Types in Blender? Include parameters, examples, warnings and best practices.

assistant: ### Poly

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

### Bézier

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

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

[image reference removed]

Bézier Curve in Edit Mode.

#### Handle Types

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

[image reference removed]

Bézier Curve Handle Types.

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

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

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

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

### NURBS

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

For more information, refer to the [Wikipedia page](https://en.wikipedia.org/wiki/NURBS).

NURBS control points have a unique weight property that determines their influence on the curve.
This weight differs from the [Goal Weight](editing/transform_panel.xhtml#curves-weight) used in soft body simulations.
Weights can be adjusted in the *W* field of the [Transform panel](editing/transform_panel.xhtml).
user: What is Introduction and how is it used in Blender Python scripting?

assistant: # Introduction

As with any other object, you edit your armature in *Edit Mode* `Tab`.

The set of bone editing tools is quite similar to the one for
[mesh](../../../../modeling/meshes/editing/introduction.xhtml) editing.

The different [poses](../../posing/index.xhtml)
you might create afterwards are based on this rest position.
So if you modify it in *Edit Mode*, all the poses already existing will also be modified.
Thus you should in general be sure that your armature is definitive before starting to
[skin](../../skinning/index.xhtml) and [pose](../../posing/index.xhtml) it!
user: What is Sharing and how is it used in Blender Python scripting?

assistant: Data-blocks can be shared among other data-blocks.

Examples where sharing data is common:

- Sharing textures among materials.
- Sharing meshes between objects (instances).
- Sharing animated actions between objects,
  for example to make all the lights dim together.

You can also share data-blocks between files, see
[linked libraries](linked_libraries/index.html).
user: Give a detailed overview of Custom Attributes: syntax, arguments, return values, common patterns.

assistant: Vertex groups, UV maps and Color Attributes are available as attributes in geometry nodes.
They are referred to by their name.
Naming collisions (e.g. a vertex group and a UV map with the same name) should be avoided.
If there is a naming collision, only one of the attributes is accessible in geometry nodes.

Attributes with any other name can also be created by nodes, when the name is used for the first time.

Note that geometry nodes does not always produce e.g. vertex groups if a node like
[Join Geometry](geometry/join_geometry.xhtml) is used.
Similarly, if the data type of a vertex group attribute is changed from the initial “Float” type,
the attribute will no longer be a vertex group.
user: Show practical ways to work with MultiresModifier(Modifier) in a Blender add-on or script – include code.

assistant: # MultiresModifier(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.MultiresModifier(*Modifier*)
:   Multiresolution mesh modifier

    boundary_smooth
    :   Controls how open boundaries are smoothed

        Type:
        :   enum in [Subdivision Boundary Smooth Items](bpy_types_enum_items/subdivision_boundary_smooth_items.html#rna-enum-subdivision-boundary-smooth-items), default `'ALL'`

    filepath
    :   Path to external displacements file

        Type:
        :   string, default “”, (never None, blend relative `//` prefix supported)

    is_external
    :   Store multires displacements outside the .blend file, to save memory

        Type:
        :   boolean, default False, (readonly)

    levels
    :   Number of subdivisions to use in the viewport

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

    quality
    :   Accuracy of vertex positions, lower value is faster but less precise

        Type:
        :   int in [1, 10], default 4

    render_levels
    :   The subdivision level visible at render time

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

    sculpt_levels
    :   Number of subdivisions to use in sculpt mode

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

    show_only_control_edges
    :   Skip drawing/rendering of interior subdivided edges

        Type:
        :   boolean, default True

    total_levels
    :   Number of subdivisions for which displacements are stored

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

    use_creases
    :   Use mesh crease information to sharpen edges or corners

        Type:
        :   boolean, default True

    use_custom_normals
    :   Interpolates existing custom normals to resulting mesh

        Type:
        :   boolean, default False

    use_sculpt_base_mesh
    :   Make Sculpt Mode tools deform the base mesh while previewing the displacement of higher subdivision levels

        Type:
        :   boolean, default False

    uv_smooth
    :   Controls how smoothing is applied to UVs

        Type:
        :   enum in [Subdivision Uv Smooth Items](bpy_types_enum_items/subdivision_uv_smooth_items.html#rna-enum-subdivision-uv-smooth-items), default `'PRESERVE_BOUNDARIES'`

    *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 GeometryNodeObjectInfo(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeObjectInfo(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.GeometryNodeObjectInfo(*GeometryNode*)
:   Retrieve information from an object

    transform_space
    :   The transformation of the vector and geometry outputs

        - `ORIGINAL`
          Original – Output the geometry relative to the input object transform, and the location, rotation and scale relative to the world origin.
        - `RELATIVE`
          Relative – Bring the input object geometry, location, rotation and scale into the modified object, maintaining the relative position between the two objects in the scene.

        Type:
        :   enum in [`'ORIGINAL'`, `'RELATIVE'`], default `'ORIGINAL'`

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

assistant: [image reference removed]

The Weld modifier.

Mode
:   Method for choosing which vertices are merged.

    All:
    :   Merge includes all geometry including loose parts.

    Connected:
    :   Merge only includes attached geometry i.e. the modifier will not merge loose parts together.

Distance
:   Maximum distance that the vertices must have each other to be merged.

Only Loose Edges Connected Mode
:   Only collapse short edges which are not adjacent to any face.
    This is useful for example to stitch the seams used in cloth simulations.

Vertex Group
:   When the *Vertex Group* option is selected, only vertices with weight above zero will be affected by the modifier.

    Invert
    :   Inverts the influence of the selected vertex group, meaning that the group
        now represents vertices that will not be merged by the modifier.

        The setting reverses the weight values of the group.