PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe ActionSlots(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ActionSlots(bpy_struct)

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

*class* bpy.types.ActionSlots(*bpy_struct*)
:   Collection of action slots

    active
    :   Active slot for this action

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

    new(*id_type*, *name*)
    :   Add a slot to the Action

        Parameters:
        :   - **id_type** (enum in [Id Type Items](bpy_types_enum_items/id_type_items.html#rna-enum-id-type-items)) – Data-block Type, The data-block type that the slot is intended for. This is combined with the slot name to create the slot’s unique identifier, and is also used to limit (on a best-effort basis) which data-blocks the slot can be assigned to.
            - **name** (*string**,* *(**never None**)*) – Name, Name of the slot. This will be made unique within the Action among slots of the same type

        Returns:
        :   Newly created action slot

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

    remove(*action_slot*)
    :   Remove the slot from the Action, including all animation that is associated with that slot

        Parameters:
        :   **action_slot** ([`ActionSlot`](bpy.types.ActionSlot.html#bpy.types.ActionSlot "bpy.types.ActionSlot")) – Action Slot, The slot 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: Provide the full official documentation entry for Internal Springs, preserving all code examples.

assistant: As stated in the introduction, cloth physics are simulated through [Springs](../introduction.xhtml#physics-cloth-introduction-springs)
connecting vertices on the surface of a mesh. But these springs only interact on the surface
and only apply to 2D surfaces. 3D or *Internal Springs* can be used to make a mesh behave similarly to
a [Soft Body](../../soft_body/index.xhtml). Internal springs can be enabled by toggling the checkbox in
the *Internal Springs* panel header.

Max Spring Creation Length
:   The maximum length an internal spring can have during creation.
    If the distance between internal points is greater than this,
    no internal spring will be created between these points.
    A length of zero means that there is no length limit.

Max Creation Diversion
:   The maximum angle that is allowed to use to connect the internal points can diverge from the vertex normal.

Check Surface Normals
:   Requires the points the internal springs connect to have opposite normal directions.

Tension
:   How much the material resists stretching.

Compression
:   How much the material resists compression.

Vertex Group
:   The *Tension* and *Compression* of internal springs can be controlled via
    a [Vertex Group](../../../modeling/meshes/properties/vertex_groups/index.xhtml) to
    specify which the portions of the mesh have internal springs or the spring strength.

Max Tension
:   Maximum tension stiffness value.

Max Compression
:   Maximum Compression stiffness value.
user: Show practical ways to work with Text Strip in a Blender add-on or script – include code.

assistant: # Text Strip

The Text strip allows you to directly display text in the Sequence editor.
The strip will display the text inserted in its text field on the final sequence.

[image reference removed]

Text effect.
user: Describe Editing Text Objects from the Blender manual or Python API, including usage steps and snippets.

assistant: # Editing Text Objects

Editing text is quite different from other object types in Blender, and happens mainly in two areas.
First, the 3D Viewport, where you type your text, and have a few shortcuts, e.g. for applying
styles (see [Font](properties.xhtml#modeling-text-character)) – note however, that most Blender shortcuts you know
in Edit Mode do not exist for texts. The second place is the Properties, especially the *Font* tab.

Editing text objects is similar to using a standard text editor but is not as
full-featured and has some differences.
The menu of the 3D Viewport header offers few options. You have no transform nor mirror tools, and so on.
To leave Edit Mode use `Tab` as it does not insert a tab character in the text,
but rather enters and exits Edit Mode, as with other object types.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The Simplify modifier.

Mode
:   Determines how to reduce points in the strokes.

    Fixed:
    :   Deletes alternated points in the strokes, except the start and end points.

        Iterations
        :   Number of times to repeat the procedure.

    Adaptive:
    :   Uses the RDP algorithm (Ramer-Douglas-Peucker algorithm) for points deletion.
        The algorithm try to obtain a similar line shape with fewer points.

        Factor
        :   Controls the amount of recursively simplifications applied by the algorithm.

    Sample:
    :   Recreates the stroke geometry with a predefined length between points.

        Length
        :   The distance between points on the recreated stroke.
            Smaller values will require more points to recreate the stroke,
            while larger values will result in fewer points needed to recreate the curve.

        Sharp Threshold
        :   Preserve corners that have sharper angle than this threshold.

    Merge:
    :   Simplifies the strokes by merging points that are closer than a specified distance to each other.

        Distance
        :   Sets the distance threshold for merging points.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: Movie Clip
:   Used to select the movie clip. For controls see [Data-Block Menu](../../../../interface/controls/templates/data_block.html#ui-data-block).

Use: 2D Stabilized Clip
:   Use the 2D stabilized version of the clip.

Use: Undistorted Clip
:   Use the undistorted version of the clip.

Below the properties, shows the frame range of the movie clip (before strip adjustments).
user: Provide the full official documentation entry for Match String Node, preserving all code examples.

assistant: # Match String Node

[image reference removed]

The *Match String* node compares two string values and outputs a Boolean result based on the selected operation.
It is useful for conditional logic involving string comparisons, such as matching object names or attribute values.
user: Show practical ways to work with Properties in a Blender add-on or script – include code.

assistant: Many nodes have settings which can affect the way they interact with inputs and outputs.
Node settings are located below the outputs and above any inputs.

[image reference removed]

An example of the controls on the Chroma Key node.
user: What is NodeGeometryBakeItems(bpy_struct) and how is it used in Blender Python scripting?

assistant: # NodeGeometryBakeItems(bpy_struct)

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

*class* bpy.types.NodeGeometryBakeItems(*bpy_struct*)
:   Collection of bake items

    new(*socket_type*, *name*)
    :   Add an item at the end

        Parameters:
        :   - **socket_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)) – Socket Type, Socket type of the item
            - **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

        Parameters:
        :   **item** ([`NodeGeometryBakeItem`](bpy.types.NodeGeometryBakeItem.html#bpy.types.NodeGeometryBakeItem "bpy.types.NodeGeometryBakeItem"), (never None)) – Item, The item to remove

    clear()
    :   Remove all items

    move(*from_index*, *to_index*)
    :   Move an item to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the item to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the item

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Geometry
:   Standard geometry input.

Selection
:   A boolean field input for each element indicating whether to include its value in the statistics result
    If the boolean is false, the corresponding value from the *Attribute* input will be ignored.

Attribute
:   The attribute field to query a statistic from.
user: What is Options and how is it used in Blender Python scripting?

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: Explain Glow Strip in complete detail according to the official Blender documentation.

assistant: # Glow Strip

This effect makes parts of an image glow brighter by working on
the luminance channel of an image.
The *Glow* is the superposition of the base image and a modified version,
where bright areas are blurred.

To “animate” the glow effect,
mix it with the base image using the Gamma Cross effect,
crossing from the base image to the glowing one.
user: Give a detailed overview of NodeSocketBundle(NodeSocketStandard): syntax, arguments, return values, common patterns.

assistant: # NodeSocketBundle(NodeSocketStandard)

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

*class* bpy.types.NodeSocketBundle(*NodeSocketStandard*)
:   Bundle socket of a node

    links
    :   List of node links from or to this socket.

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

        (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: Provide the full official documentation entry for Properties, preserving all code examples.

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

assistant: # Shading

Alternatively, you can choose which faces to smooth by entering *Edit Mode*,
then selecting some faces and picking *Shade Smooth* from the *Face Menu*.

When the mesh is in *Edit Mode*,
only the selected faces will receive the “smoothing” attribute.
You can set faces as flat (removing the “smoothing” attribute)
in the same way by selecting edges and picking the *Shade Flat* from the *Face Menu*.
user: Describe Ptcache Operators from the Blender manual or Python API, including usage steps and snippets.

assistant: # Ptcache Operators

bpy.ops.ptcache.add()
:   Add new cache

bpy.ops.ptcache.bake(*\**, *bake=False*)
:   Bake physics

    Parameters:
    :   **bake** (*boolean**,* *(**optional**)*) – Bake

bpy.ops.ptcache.bake_all(*\**, *bake=True*)
:   Bake all physics

    Parameters:
    :   **bake** (*boolean**,* *(**optional**)*) – Bake

bpy.ops.ptcache.bake_from_cache()
:   Bake from cache

bpy.ops.ptcache.free_bake()
:   Delete physics bake

bpy.ops.ptcache.free_bake_all()
:   Delete all baked caches of all objects in the current scene

bpy.ops.ptcache.remove()
:   Delete current cache
user: How do I use Driver(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # Driver(bpy_struct)

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

*class* bpy.types.Driver(*bpy_struct*)
:   Driver for the value of a setting based on an external value

    expression
    :   Expression to use for Scripted Expression

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

    is_simple_expression
    :   The scripted expression can be evaluated without using the full Python interpreter

        Type:
        :   boolean, default False, (readonly)

    is_valid
    :   Driver could not be evaluated in past, so should be skipped

        Type:
        :   boolean, default False

    type
    :   Driver type

        Type:
        :   enum in [`'AVERAGE'`, `'SUM'`, `'SCRIPTED'`, `'MIN'`, `'MAX'`], default `'AVERAGE'`

    use_self
    :   Include a ‘self’ variable in the name-space, so drivers can easily reference the data being modified (object, bone, etc…)

        Type:
        :   boolean, default False

    variables
    :   Properties acting as inputs for this driver

        Type:
        :   [`ChannelDriverVariables`](bpy.types.ChannelDriverVariables.html#bpy.types.ChannelDriverVariables "bpy.types.ChannelDriverVariables") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`DriverVariable`](bpy.types.DriverVariable.html#bpy.types.DriverVariable "bpy.types.DriverVariable"), (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](#bpy.types.Driver.type "bpy.types.Driver.type")
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.brush`](bpy.context.html#bpy.context.brush "bpy.context.brush") - [`BlendData.brushes`](bpy.types.BlendData.html#bpy.types.BlendData.brushes "bpy.types.BlendData.brushes") - [`BlendDataBrushes.create_gpencil_data`](bpy.types.BlendDataBrushes.html#bpy.types.BlendDataBrushes.create_gpencil_data "bpy.types.BlendDataBrushes.create_gpencil_data") - [`BlendDataBrushes.new`](bpy.types.BlendDataBrushes.html#bpy.types.BlendDataBrushes.new "bpy.types.BlendDataBrushes.new") | - [`BlendDataBrushes.remove`](bpy.types.BlendDataBrushes.html#bpy.types.BlendDataBrushes.remove "bpy.types.BlendDataBrushes.remove") - [`Paint.brush`](bpy.types.Paint.html#bpy.types.Paint.brush "bpy.types.Paint.brush") - [`Paint.eraser_brush`](bpy.types.Paint.html#bpy.types.Paint.eraser_brush "bpy.types.Paint.eraser_brush") |
user: Provide the full official documentation entry for CollectionLightLinking(bpy_struct), preserving all code examples.

assistant: # CollectionLightLinking(bpy_struct)

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

*class* bpy.types.CollectionLightLinking(*bpy_struct*)
:   Light linking settings of objects and children collections of a collection

    link_state
    :   Light or shadow receiving state of the object or collection

        Type:
        :   enum in [`'INCLUDE'`, `'EXCLUDE'`], default `'INCLUDE'`

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

assistant: Renders only a single 2D section of the domain object.

Axis
:   Auto:
    :   Adjust slice direction according to the view direction.

    X/Y/Z:
    :   Slice along the X/Y/Z axis.

Position
:   Position of the slice relative to the length of the respective domain side.

Gridlines Closest Interpolation Only
:   Display gridlines to differentiate the underlying cells in the current slice of the fluid domain.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: R
:   The radial distance from the origin.

Phi
:   The azimuthal angle (horizontal rotation) around the Z axis, measured in radians.

Theta
:   The polar angle (vertical inclination) from the Z axis, measured in radians.
user: Provide the full official documentation entry for Technical Details, preserving all code examples.

assistant: In the Soft Body world, vertices of meshes are treated as particles having a mass.
Their movement is determined by the forces affecting them. Beside other forces
the individual particles can interact with another along edges using a physical model
which is very close to shock absorbers used in cars. The working parts are:

- A spring trying to keep the particles at a certain distance.
  How hard the spring tries to do that is controlled by the soft body parameter *Stiffness*.
- A damping element to calm the movement down.
  The resistance the element builds up against motion is controlled by the soft body parameter *Damping*.
user: Give a detailed overview of Grid Fill: syntax, arguments, return values, common patterns.

assistant: # Grid Fill

*Grid Fill* fills a selected region with a quad grid, using either edge loops or selected faces
as input to determine the boundary.

It supports two main use cases:

- **Edge Loops**: A pair of open edge loops, or a single closed edge loop.
- **Selected Faces**: A connected selection of faces with a clear outer boundary.

The operator attempts to fit a grid of quads within the defined boundary using a predictable and structured pattern.

Span
:   Specifies the number of columns in the grid.

Offset
:   Defines the vertex that is considered to be the corner of the grid.
    By default, this is the active vertex. Use this to rotate the grid layout.

Simple Blending
:   Use a simpler interpolation algorithm for generating grid geometry from boundary loops.
    This method is better suited for flat surfaces or cases where preserving curvature gives undesirable results.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_face_grid-fill_before.png   Input. | ../../../../_images/modeling_meshes_editing_face_grid-fill_after.png   Grid Fill result. |
user: How do I use Interface in Blender? Include parameters, examples, warnings and best practices.

assistant: ### View Menu

Area
:   Area controls. See the [user interface](../interface/window_system/areas.xhtml)
    documentation for more information.

### Info Menu

Select All `A`
:   Selects all entries.

Deselect All `Alt`-`A`
:   Deselects all entries.

Invert Selection `Ctrl`-`I`
:   Selects non-selected entries and deselects selected ones.

Toggle Selection
:   Selects all entries if there are currently no selected ones,
    and deselects them otherwise.

Box Select `B`
:   Lets you drag a box and adds the entries that overlap it to the selection.

Delete `X`, `Delete`
:   Removes the selected entries from the log.

Copy `Ctrl`-`C`
:   Copies the selected entries to the clipboard.
user: Describe CurvesModifier(StripModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CurvesModifier(StripModifier)

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

*class* bpy.types.CurvesModifier(*StripModifier*)
:   RGB curves modifier for sequence strip

    curve_mapping
    :   Type:
        :   [`CurveMapping`](bpy.types.CurveMapping.html#bpy.types.CurveMapping "bpy.types.CurveMapping"), (readonly)

    open_mask_input_panel
    :   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: Explain Shape in complete detail according to the official Blender documentation.

assistant: Most of the settings in the *Shape* panel are shared with those of
[Curves](../curves/properties/shape.xhtml)
data-blocks, please refer to those for details.

Fast Editing
:   Does not fill the letters in Edit Mode, only show their outline.
user: What is Options and how is it used in Blender Python scripting?

assistant: Scene
:   A [Data-Block Menu](../../../../interface/controls/templates/data_block.html#ui-data-block) to select or create the scene to render from.

Input
:   Input type to use for the Scene strip.

    Camera:
    :   Use the Scene’s 3D camera as input.

    Sequencer:
    :   Use the scene’s Sequencer timeline as input, allowing one scene to reuse
        another scene’s edit (instead of taking the render output from the scene).

        This is similar to how [Meta Strips](../meta.html) work,
        with the added advantage of supporting multiple instances of the same data.

Camera
:   This can be used to override the scene’s camera with any other object.

    It is useful to support switching views within a single scene.

Show
:   Annotations
    :   Shows [Annotations](../../../../interface/annotate_tool.html) while in non-render
        [Preview Shading Modes](../../../../editors/video_sequencer/preview/sidebar.html#bpy-types-rendersettings-sequencer-gl-preview)
        i.e. *Solid* or *Wireframe* mode.

    Transparent
    :   Creates a transparent background.
        This is useful for doing overlays like rendering out Grease Pencil films via the Sequencer.

### Sound

Strip Volume
:   Volume of the audio taken from the chosen scene.
user: Show practical ways to work with Bpy.Types.Sphfluidsettings in a Blender add-on or script – include code.

assistant: ed Properties Inherited Functions References
user: Describe NodeGeometryCaptureAttributeItem(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeGeometryCaptureAttributeItem(bpy_struct)

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

*class* bpy.types.NodeGeometryCaptureAttributeItem(*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)

    data_type
    :   Type:
        :   enum in [Attribute Type Items](bpy_types_enum_items/attribute_type_items.html#rna-enum-attribute-type-items), default `'FLOAT'`

    name
    :   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: Show practical ways to work with Workflow in a Blender add-on or script – include code.

assistant: The workflow for working with pull requests can be found in the
[Blender Developer’s Documentation](https://developer.blender.org/docs/handbook/contributing/pull_requests/).

Note, some text in the above guideline is focused on the main Blender repository, however, the workflow is the same
for any Blender project.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

Opacity Modifier.

Mode
:   The color transformation will be applied to the stroke/fill color or stroke Hardness.
    When Hardness is selected the opacity affects the stroke’s transparency (alpha) from the center to the border.

    Stroke & Fill, Stroke, Fill, or Hardness

Uniform Opacity
:   When enabled, makes the opacity equal for the entire strokes.

    Strength
    :   Absolute opacity for the stroke points.

Opacity Factor
:   Controls the opacity value of the stroke points.
    A value of 1.0 respect the original alpha value of the points,
    a shift less than 1.0 make the points more transparent than originally,
    and a shift greater than 1.0 make the points more opaque than originally.

    Sets value to 2.0 makes the points alpha fully opaque.

### Influence

See [Influence Filters](../introduction.xhtml#grease-pencil-modifier-influence-filters).
user: Show practical ways to work with Extension Licenses in a Blender add-on or script – include code.

assistant: # Extension Licenses

The [Blender Extensions Platform](https://extensions.blender.org)
only supports free and open source extensions compliant with the
[Blender’s license](https://www.blender.org/about/license):

- For add-ons, the required license is
  [GNU General Public License v3.0 or later](https://spdx.org/licenses/GPL-3.0-or-later.html).
- For themes, the recommended license is
  [GNU General Public License v3.0 or later](https://spdx.org/licenses/GPL-3.0-or-later.html),
  but any [GPL-compatible license](https://www.gnu.org/licenses/license-list.en.html#GPLCompatibleLicenses)
  is supported.
- For assets used in add-ons, the required license is
  [Public Domain (CC0)](https://spdx.org/licenses/CC0-1.0.html).
user: What is Markers and how is it used in Blender Python scripting?

assistant: # Markers

Markers are used to denote frames with key points or significant events within an animation.
E.g. it could be that a character’s animation starts, the camera changes position, or a door opens.
Markers can be given names to make them more meaningful at a quick glance.
They are available in many of Blender’s editors.

Markers can be created and edited in the following editors:

- [Graph Editor](../editors/graph_editor/introduction.html)
- [Dope Sheet](../editors/dope_sheet/introduction.html)
- [NLA Editor](../editors/nla/index.html)
- [Video Sequence Editor](../video_editing/index.html)
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: 1. Shift-select the object to be parented (the child object).
2. Select the parent mesh object and enter *Edit Mode*.
3. Select **one or three** vertices that will define the parent relationship.
4. Press `Ctrl`-`P`
user: Describe Goal from the Blender manual or Python API, including usage steps and snippets.

assistant: # Goal

Enabling this tells Blender to use the motion from animations
(F-Curves, armatures, parents, lattices, etc.) in the simulation.
The “goal” is the desired end position for vertices based on this animation.

See [exterior forces](../forces/exterior.xhtml#physics-softbody-forces-exterior-goal) for details.

Vertex Group
:   Use a vertex group to allow per-vertex goal weights (multiplied by the *Default* goal).
user: How do I use Troubleshooting macOS – Intel in Blender? Include parameters, examples, warnings and best practices.

assistant: # Troubleshooting macOS – Intel

Blender uses OpenGL for the 3D Viewport and user interface. The graphics processing unit (GPU) and driver have a big
impact on Blender’s behavior and performance.

This section lists possible solutions for graphics glitches, problems with EEVEE and Cycles, and crashes related to
your GPU.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Mesh Cache Modifier.

Format
:   Specifies the input file format. The modifier currently supports `.mdd` and `.pc2`.

File Path
:   Path to the external cache file containing the animation data.

Influence
:   Controls the strength of the deformation. Lower values blend the cached animation with the original mesh shape.

Deform Mode
:   Determines how the cache data influences the mesh:

    Overwrite:
    :   Replaces vertex positions with those from the cache file.

    Integrate:
    :   Blends the cache deformation with existing deformations, such as shape keys or modifiers.

Interpolation
:   Controls how frames between cache data are handled:

    None:
    :   Uses only the raw frame data from the cache without interpolation.

    Linear:
    :   Blends between frames for smoother transitions, useful when cache frames do not align perfectly with the scene
        frames.

Vertex Group
:   If set, restrict the effect to the only vertices in that vertex group.

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

        The setting reverses the weight values of the group.

### Time Remapping

Time Mode
:   Defines how animation time is interpreted:

    Frame:
    :   Ignores timing data from the cache and plays back frames directly.
        This mode provides direct control over playback speed.

    Time:
    :   Uses the cache’s timing data, including offsets and frame durations.

    Factor:
    :   Maps the entire animation to a range between `0` and `1` for precise control.

Play Mode
:   Specifies how playback timing is determined:

    Scene:
    :   Uses the scene’s current frame for playback.

        Frame Start
        :   Defines the starting frame for playback.

        Frame Scale
        :   Adjusts the playback speed by scaling time.

    Custom:
    :   Allows manual control of animation timing.

        Evaluation Value
        :   Determines animation playback position, which can be animated for precise control.

### Axis Mapping

Forward/Up Axis
:   Specifies the forward and up axes of the imported animation, ensuring proper orientation.

Flip Axis
:   Flips the animation along a chosen axis if the imported data requires correction.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Color
:   Tint rays passing through the portal.

Position
:   Ray start position at new location. Defaults to the current position,
    matching the Position output of the
    [Geometry node](../input/geometry.xhtml).

Direction
:   Ray direction at the new location. Defaults to the current view direction,
    which is the same as the negation of the Incoming output of the
    [Geometry node](../input/geometry.xhtml).
user: What is Strengths and how is it used in Blender Python scripting?

assistant: Default
:   Goal weight/strength for all vertices when no *Vertex Group* is assigned.
    If you use a vertex group the weight of a vertex defines its goal.

Min/Max
:   When you use a vertex group, you can use the *Minimum* and *Maximum* to fine-tune (clamp) the weight values.
    The lowest vertex weight will become *Minimum*, the highest value becomes *Maximum*.
user: Provide the full official documentation entry for Module Functions, preserving all code examples.

assistant: bmesh.from_edit_mesh(*mesh*)
:   Return a BMesh from this mesh, currently the mesh must already be in editmode.

    Parameters:
    :   **mesh** ([`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh")) – The editmode mesh.

    Returns:
    :   the BMesh associated with this mesh.

    Return type:
    :   `bmesh.types.BMesh`

bmesh.new(*\**, *use_operators=True*)
:   Parameters:
    :   **use_operators** (*bool*) – Support calling operators in [`bmesh.ops`](bmesh.ops.html#module-bmesh.ops "bmesh.ops") (uses some extra memory per vert/edge/face).

    Returns:
    :   Return a new, empty BMesh.

    Return type:
    :   `bmesh.types.BMesh`

bmesh.update_edit_mesh(*mesh*, *\**, *loop_triangles=True*, *destructive=True*)
:   Update the mesh after changes to the BMesh in editmode,
    optionally recalculating n-gon tessellation.

    Parameters:
    :   - **mesh** ([`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh")) – The editmode mesh.
        - **loop_triangles** (*bool*) – Option to recalculate n-gon tessellation.
        - **destructive** (*bool*) – Use when geometry has been added or removed.
user: Give a detailed overview of Separate: syntax, arguments, return values, common patterns.

assistant: Separates curve objects that are made of multiple distinct curves into their own objects.

Note, if there is only one curve in a Curve object,
This operation will create a new Curve object with no control points.
user: How do I use Interaction in Real-Time in Blender? Include parameters, examples, warnings and best practices.

assistant: To work with a soft body simulation, you will find it handy to use the Timeline editor.
You can change between frames and the simulation will always be shown in the actual state.
You can interact in real-time with the simulation,
e.g. by moving collision objects or shaking a soft body object.

You can then select the soft body object while running the simulation and *Apply*
the modifier in the *Modifiers* tab of the Properties.
This makes the deformation permanent.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Image
:   Standard color input.

Minimum
:   Determines the lowest values that are considered foreground.
    (Which is supposed to be – relatively – high values: from this value to 1.0.)

Maximum
:   Determines the highest values that are considered to be background objects.
    (Which is supposed to be – relatively – low values: from 0.0 to this value.)

Color Space
:   This button selects what color model the channels will represent.

    RGB, HSV, YUV, YCbCr

Key Channel
:   This button selects the channel, defined by the *Color Space*, to use to determine the matte.

Limit Method
:   Method to calculate the difference between levels.

    Max:
    :   Limit by the maximum of the other two channels other than the *Key Channel*.

    Single:
    :   Limit by the maximum of the selected *Limit Channel*.

Limit Channel
:   The channel to use when computing the maximum, the options are defined by the *Color Space*.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`bpy.context.active_pose_bone`](bpy.context.html#bpy.context.active_pose_bone "bpy.context.active_pose_bone") - [`bpy.context.pose_bone`](bpy.context.html#bpy.context.pose_bone "bpy.context.pose_bone") - [`bpy.context.selected_pose_bones`](bpy.context.html#bpy.context.selected_pose_bones "bpy.context.selected_pose_bones") - [`bpy.context.selected_pose_bones_from_active_object`](bpy.context.html#bpy.context.selected_pose_bones_from_active_object "bpy.context.selected_pose_bones_from_active_object") - [`bpy.context.visible_pose_bones`](bpy.context.html#bpy.context.visible_pose_bones "bpy.context.visible_pose_bones") - [`Object.convert_space`](bpy.types.Object.html#bpy.types.Object.convert_space "bpy.types.Object.convert_space") | - [`Pose.bones`](bpy.types.Pose.html#bpy.types.Pose.bones "bpy.types.Pose.bones") - [`PoseBone.bbone_custom_handle_end`](#bpy.types.PoseBone.bbone_custom_handle_end "bpy.types.PoseBone.bbone_custom_handle_end") - [`PoseBone.bbone_custom_handle_start`](#bpy.types.PoseBone.bbone_custom_handle_start "bpy.types.PoseBone.bbone_custom_handle_start") - [`PoseBone.child`](#bpy.types.PoseBone.child "bpy.types.PoseBone.child") - [`PoseBone.custom_shape_transform`](#bpy.types.PoseBone.custom_shape_transform "bpy.types.PoseBone.custom_shape_transform") - [`PoseBone.parent`](#bpy.types.PoseBone.parent "bpy.types.PoseBone.parent") |
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Density Grid
:   The resulting float grid representing the density of the mesh.
    Voxels inside the mesh will have higher density values, while voxels
    outside the mesh will approach zero. The smooth transition is defined by
    the *Gradient Width* parameter.
user: Explain Light Probe Sphere in complete detail according to the official Blender documentation.

assistant: # Light Probe Sphere

A light probe sphere records the light incoming from many directions at a single location.

They are used for smooth and semi-rough reflections.
Sphere probes smoothly blend to light probe volume lighting for completely diffuse reflections.

If *Raytracing* is turned on, they are used as a fallback if a ray misses.

Adjusting their resolution is done inside the [Scene data](../scene_settings.xhtml) panel.

The world also has an internal light probe sphere with a resolution that can be adjusted
in the [World data](../world_settings.xhtml) panel.
user: What is Set Handle Type and how is it used in Blender Python scripting?

assistant: Handle types are a property of [Bézier curves](../structure.html#curve-bezier) and
can be used to alter features of the curve.
For example, switching to *Vector handles* can be used to create curves with sharp corners.
Read the [Bézier curves](../structure.html#curve-bezier-handle-type) page for more details.

Toggle Free/Align
:   Additionally, this operator can be used to toggle between Free and Aligned handle types.
user: Provide the full official documentation entry for Creating Extensions, preserving all code examples.

assistant: # Creating Extensions

Extensions are **add-ons** or **themes** used to extend the core functionality of Blender.
They are shared in online platforms, and can be installed and updated from within Blender.

The official extensions platform for the Blender project is [extensions.blender.org](https://extensions.blender.org).
Other third party sites can also be supported, as long as they follow the Extensions Platform specification.
user: Show practical ways to work with CompositorNodeInvert(CompositorNode) in a Blender add-on or script – include code.

assistant: # CompositorNodeInvert(CompositorNode)

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

*class* bpy.types.CompositorNodeInvert(*CompositorNode*)
:   Invert colors, producing a negative

    *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")

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Noise Texture Node in complete detail according to the official Blender documentation.

assistant: # Noise Texture Node

[image reference removed]

The *Noise Texture* node evaluates a fractal Perlin noise at the input texture coordinates.
It can be used for a single Perlin noise evaluation, or for combining multiple octaves
(layers) with increasingly finer detail.
user: Show practical ways to work with Sample Grid Index Node in a Blender add-on or script – include code.

assistant: # Sample Grid Index Node

[image reference removed]

The *Sample Grid Index* node retrieves values directly from a voxel grid at
specific voxel indices rather than at arbitrary spatial positions.
Unlike the [Sample Grid](sample_grid.html)
node, which interpolates between voxels in object space, this node reads the
exact stored value of the voxel located at the specified integer coordinates.

This makes it useful for working in *index space*, for example when performing
voxel neighborhood lookups, procedural filtering, or sampling based on values
from the [Voxel Index](../read/voxel_index.html) node.
user: What is LineStyleGeometryModifier_Simplification(LineStyleGeometryModifier) and how is it used in Blender Python scripting?

assistant: # LineStyleGeometryModifier_Simplification(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_Simplification(*LineStyleGeometryModifier*)
:   Simplify the stroke set

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    tolerance
    :   Distance below which segments will be merged

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Geometry Modifier Type Items](bpy_types_enum_items/linestyle_geometry_modifier_type_items.html#rna-enum-linestyle-geometry-modifier-type-items), default `'2D_OFFSET'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        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](#bpy.types.LineStyleGeometryModifier_Simplification.type "bpy.types.LineStyleGeometryModifier_Simplification.type")
user: Provide the full official documentation entry for Grease Pencil, preserving all code examples.

assistant: Playback Only
:   Activates the simplification process only during animation playback.

Fill
:   Shows the fill component in Grease Pencil materials.

Modifiers
:   Shows Grease Pencil [modifiers](../../../grease_pencil/modifiers/index.xhtml).

Shader Effects
:   Shows Grease Pencil [visual effects](../../../grease_pencil/modifiers/index.xhtml).

Layer Tinting
:   Shows layers tint overrides.

Anti-Aliasing
:   Use [Anti-Aliasing](../../../glossary/index.xhtml#term-Anti-Aliasing) to smooth stroke edges. The amount of anti-aliasing can be adjusted by
    the [SMAA Threshold](grease_pencil.xhtml#bpy-types-scenegpencil-antialias-threshold).
user: How do I use Transform in Blender? Include parameters, examples, warnings and best practices.

assistant: # Transform

[image reference removed]

The Transform panel for armatures in Edit Mode.

We will not detail here the various transformations of bones, nor things like axis locking, pivot points, and so on,
as they are common to most object editing, and already described in
the [mesh section](../../../../scene_layout/object/editing/transform/control/index.xhtml).
The same goes for mirroring,
as it is nearly the same as with [mesh editing](../../../../modeling/meshes/editing/mesh/mirror.xhtml).
Just keep in mind that bones’ roots and tips behave more or less like meshes’ vertices,
and bones themselves act like edges in a mesh.

As you know, bones can have two types of relationships: They can be parented,
and in addition connected. Parented bones behave in *Edit Mode* exactly as if they
had no relations. They can be moved, rotated, scaled, etc. without affecting their descendants.
However, connected bones must always have parent’s tips connected to child’s roots,
so by transforming a bone, you will affect all its connected parent/children/siblings.

While with other transform tools, the “local axes” means the object’s axes,
here they are the bone’s own axes (when you lock to a local axis,
by pressing the relevant key twice, the constraint is applied along the selected bone’s local axis,
not the armature object’s axis).

Finally, you can edit in the *Transform* panel in the Sidebar region
the positions and radius of both joints of the active selected bone,
as well as its [roll rotation](bone_roll.xhtml#armature-bone-roll).