PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use LineStyleGeometryModifier_2DOffset(LineStyleGeometryModifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # LineStyleGeometryModifier_2DOffset(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_2DOffset(*LineStyleGeometryModifier*)
:   Add two-dimensional offsets to stroke backbone geometry

    end
    :   Displacement that is applied from the end of the stroke

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    start
    :   Displacement that is applied from the beginning of the stroke

        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

    x
    :   Displacement that is applied to the X coordinates of stroke vertices

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

    y
    :   Displacement that is applied to the Y coordinates of stroke vertices

        Type:
        :   float in [-inf, 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](#bpy.types.LineStyleGeometryModifier_2DOffset.type "bpy.types.LineStyleGeometryModifier_2DOffset.type")
user: Give a detailed overview of Workflow: syntax, arguments, return values, common patterns.

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

assistant: # Viewport Display

The Display Panel controls how particles are displayed in the 3D Viewport.
This does not necessarily determine how they will appear when rendered.

Display As
:   None
    :   The particles are not shown in the 3D Viewport and are not rendered.
        The emitter may be rendered though.

    Rendered
    :   Particles are displayed the way they are rendered.

    Point
    :   Particles are displayed as square points.
        Their size is independent of the distance from the camera.

    Circle
    :   Particles are displayed as circles that face the view.
        Their size is independent of the distance from the camera.

    Cross
    :   Particles are displayed as 6-point crosses that align to the rotation of the particles.
        Their size is independent of the distance from the camera.

    Axis
    :   Particles are displayed as 3-point axes.
        This is useful if you want to see the orientation and rotation of particles in the viewport.
        Increase the *Display Size* until you can clearly distinguish the axis.

Color
:   The Color Menu allows you to display particle’s color according to certain particle properties.

    None
    :   Particles are black.

    Material
    :   Particles are colored according to the material they are given.

    Velocity
    :   Color particles according to their speed.
        The color is a ramp from blue to green to red, Blue being the slowest,
        and Red being velocities approaching the value of *Max* or above.
        Increasing *Max* allows for a wider range of particle velocities.

    Acceleration
    :   Color particles according to their acceleration.

Amount
:   Specifies the percentage of all particles to show in the viewport (all particles are still rendered).

Show Emitter
:   Make instancer visible in viewport.
user: Explain Scripted Expression in complete detail according to the official Blender documentation.

assistant: [image reference removed]

A security warning in the Drivers panel.

[image reference removed]

An Auto-run warning in the Info editor’s header.

By default Blender will restrict execution of Python scripts.

If using a *Scripted Expression* Driver Type that doesn’t follow
the [Simple Expressions](drivers_panel.xhtml#drivers-simple-expressions)
subset, you will have to open the file as *Trusted Source*,
or set *Auto Run Python Scripts* in Preferences ‣ Save & Load ‣ Blender Files.

|  |  |
| --- | --- |
| ../../_images/animation_drivers_troubleshooting_autorun-file-browser.png   The Trusted Source checkbox in the File Browser. | ../../_images/animation_drivers_troubleshooting_autorun-user-preference.png   The Auto Run Python Scripts checkbox in the Preferences. |
user: How do I use Importing in Blender? Include parameters, examples, warnings and best practices.

assistant: ### General

Scale
:   Value by which to scale the imported objects in relation to the world’s origin.

Scene Unit
:   Apply current scene’s unit (as defined by unit scale) to imported data.

Forward / Up Axis
:   Since many applications use a different axis for pointing upwards, these are axis conversion for these settings,
    Forward and up axes – By mapping these to different axes you can convert rotations
    between applications default up and forward axes.

    Blender uses Y forward, Z up (since the front view looks along the +Y direction).
    For example, it is common for applications to use Y as the up axis, in that case -Z forward, Y up is needed.

### Options

Facet Normals
:   Use (import) facet normals (note that this will still give flat shading).

Validate Mesh
:   Check the imported mesh for corrupt data and fix it if necessary.
    When disabled, erroneous data may cause crashes displaying or editing the meshes.
    This option will make the importing slower but is recommended, as data errors are not always obvious.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Image
:   The image socket can be used to connect to the Group Input node.
    If this is not connected the image can be opened or selected from the node.

Vector
:   Texture coordinate for texture look-up. If this socket is left unconnected,
    the Position attribute is used.

Frame
:   If the Image supports animation, the frame can be set here.
    This can be keyframed so that the image changes between frames.
user: Explain CrossStrip(EffectStrip) in complete detail according to the official Blender documentation.

assistant: # CrossStrip(EffectStrip)

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

*class* bpy.types.CrossStrip(*EffectStrip*)
:   Crossfade Strip

    input_1
    :   First input for the effect strip

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

    input_2
    :   Second input for the effect strip

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

    input_count
    :   Type:
        :   int in [0, inf], default 0, (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: Describe Interface Elements from the Blender manual or Python API, including usage steps and snippets.

assistant: Standard markup for interface elements:

- `` :kbd:`LMB` `` – keyboard and mouse shortcuts.
- `*Mirror*` – interface labels (buttons, panels, etc.).
- `` :menuselection:`3D Viewport --> Add --> Mesh --> Monkey` `` – navigation paths through menus.
user: Describe Displace Hair Curves from the Blender manual or Python API, including usage steps and snippets.

assistant: # Displace Hair Curves

The *Displace Hair Curves* node offsets the shape or position of hair curves using a displacement vector.
This allows for procedural control over hair movement, direction, or surface alignment.
The displacement can be applied in object, world, or surface normal space, depending on the configuration.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Volume
:   The input volume geometry to which the grid will be added or replaced.

Name
:   The name under which the grid will be stored in the volume.
    This name is used later to retrieve the grid using the *Get Named Grid*
    node or in the Spreadsheet editor under the *Volume Grids* section.

Grid
:   The grid to store within the volume.
    The grid must have a compatible resolution and transform with the target volume.
    The grid’s data type must match the node’s *Data Type* property.
user: Provide the full official documentation entry for CompositorNodeGroup(CompositorNode), preserving all code examples.

assistant: # CompositorNodeGroup(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.CompositorNodeGroup(*CompositorNode*)
:   node_tree
    :   Type:
        :   [`NodeTree`](bpy.types.NodeTree.html#bpy.types.NodeTree "bpy.types.NodeTree")

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

assistant: As covered in [Life Time](#life-time), data-blocks are typically removed when they are no longer used.
They can also be manually *unlinked* or *deleted*.

Unlinking a data-block means that its user won’t use it anymore.
This can be achieved by clicking on the “X” icon next to a data-block’s name.
If you unlink a data-block from all of its users,
it will eventually be deleted by Blender as described above (unless it is a protected one).

Deleting a data-block directly erases it from the blend-file, automatically unlinking it from all of its users.
This can be achieved by `Shift`-`LMB` on the “X” icon next to its name.

Those two operations are also available in the context menu
when `RMB`-clicking on a data-block in the *Outliner*.
user: What is Tool Settings and how is it used in Blender Python scripting?

assistant: ### Brush Asset

The asset selector can be used to open a pop-up asset browser to select the active brush asset for the tool.

See [Asset Operators](../../../../sculpt_paint/brush/brush_management.xhtml#brush-management-utility-operators) for more information.

### Brush Settings

You can also configure the brush main settings exposed on the Tool Settings for convenience.

Direction `Ctrl`
:   The portion of area to fill.

    Normal:
    :   Fills the area inside the shape under the cursor.

    Inverted:
    :   When clicking outside the drawing, fills all shapes touching the area under the cursor.

Precision
:   Multiplier for fill boundary accuracy.
    Higher values are more accurate but slower.

Dilate/Contract
:   Size in pixels to expand or shrink the fill area from the strokes boundary.

Thickness
:   The thickness radius of the boundary stroke in pixels.

#### Advanced

Boundary
:   Sets the type of fill boundary limits calculation to perform.

    All:
    :   Use the thickness of the strokes and the editing lines together.

    Strokes:
    :   Use only the thickness of the strokes (ignore edit lines).

    Edit Lines:
    :   Use only the edit lines (ignore strokes).

    Show Lines (eye icon)
    :   Toggle show auxiliary lines to see the fill boundary.

Layers
:   Determines which [Layers](../../../properties/layers.xhtml) are used for boundary strokes.

    Visible:
    :   Calculates boundaries based on all visible layers.

    Active:
    :   Calculates boundaries based on the active layer.

    Layer Above:
    :   Calculates boundaries based on the layer above the active layer.

    Layer Below:
    :   Calculates boundaries based on the layer below the active layer.

    All Above:
    :   Calculates boundaries based on all layers above the active layer.

    All Below:
    :   Calculates boundaries based on all layers below the active layer.

Simplify
:   Number of simplify steps to apply to the boundary line.
    Higher values reduce the accuracy of the final filled area.

Ignore Transparent
:   When enabled, strokes with transparency does not take into account on fill boundary calculations.

    The value slider controls the threshold to consider a material transparent.

Limit to Viewport
:   When enabled, fill only visible areas in the viewport.

Auto-Remove Fill Guides
:   When enabled, after creating a fill, automatically remove the fill guide strokes.

##### Gap Closure

Gap closure lines are automatic temporarily lines that help to close gaps on the strokes.

Size
:   Control the Size of the line extension or the circumference to use to calculate the lines that will close the gaps.

Mode `S`
:   Sets the type of Gap closure method to use.

    Radius:
    :   Uses the Radius of circumference of opened nearest points to calculate a line that close the gap.

    Extend:
    :   Extends the opened strokes to close gaps.

Visual Aids
:   Toggle show closure lines helper.

Strokes Collision `D`
:   Check if extend lines collide with strokes, stopping the extension if a collision is detected.
user: Provide the full official documentation entry for Spline Parameter Node, preserving all code examples.

assistant: # Spline Parameter Node

[image reference removed]

The *Spline Parameter* node outputs how far along each spline a control point is.
The *Factor* output is different from dividing the index by the total number of control points,
because the control points might not be equally spaced along the curve.

The first value is zero, so the output corresponds to the length at the control point rather than
including the length of the following segment.

When used on the spline domain, the node outputs the portion of the total length of the curve (including
all splines) has been traversed at the start of each spline. The order of the curve’s splines is visible
in the [Spreadsheet Editor](../../../../editors/spreadsheet.xhtml).
user: Provide the full official documentation entry for Data Names, preserving all code examples.

assistant: ### Naming Limitations

A common mistake is to assume newly created data is given the requested name.
This can cause bugs when you add data (normally imported) then reference it later by name:

```
bpy.data.meshes.new(name=meshid)

# Normally some code, function calls, etc.
bpy.data.meshes[meshid]
```

Or with name assignment:

```
obj.name = objname

# Normally some code, function calls, etc.
obj = bpy.data.meshes[objname]
```

Data names may not match the assigned values if they exceed the maximum length, are already used or an empty string.

It’s better practice not to reference objects by names at all,
once created you can store the data in a list, dictionary, on a class, etc;
there is rarely a reason to have to keep searching for the same data by name.

If you do need to use name references, it’s best to use a dictionary to maintain
a mapping between the names of the imported assets and the newly created data,
this way you don’t run this risk of referencing existing data from the blend-file, or worse modifying it.

```
# Typically declared in the main body of the function.
mesh_name_mapping = {}

mesh = bpy.data.meshes.new(name=meshid)
mesh_name_mapping[meshid] = mesh

# Normally some code, or function calls, etc.

# Use own dictionary rather than `bpy.data`.
mesh = mesh_name_mapping[meshid]
```

### Library Collisions

Blender keeps data names unique ([`bpy.types.ID.name`](bpy.types.ID.html#bpy.types.ID.name "bpy.types.ID.name")) so you can’t name two objects,
meshes, scenes, etc., the same by accident.
However, when linking in library data from another blend-file naming collisions can occur,
so it’s best to avoid referencing data by name at all.

This can be tricky at times and not even Blender handles this correctly in some cases
(when selecting the modifier object for example, you can’t select between multiple objects with the same name),
but it’s still good to try avoiding these problems in this area.
If you need to select between local and library data, there is a feature in `bpy.data` members to allow for this.

```
# Typical name lookup, could be local or library.
obj = bpy.data.objects["my_obj"]

# Library object name lookup using a pair,
# where the second argument is the library path matching bpy.types.Library.filepath.
obj = bpy.data.objects["my_obj", "//my_lib.blend"]

# Local object name look up using a pair,
# where the second argument excludes library data from being returned.
obj = bpy.data.objects["my_obj", None]

# Both the examples above also works for `get`.
obj = bpy.data.objects.get(("my_obj", None))
```
user: Give a detailed overview of CompositorNodeConvertToDisplay(CompositorNode): syntax, arguments, return values, common patterns.

assistant: # CompositorNodeConvertToDisplay(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.CompositorNodeConvertToDisplay(*CompositorNode*)
:   Convert from scene linear to display color space, with a view transform and look for tone mapping

    display_settings
    :   Color management display device settings

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

    view_settings
    :   Color management view transform settings

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

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

assistant: [Markers](../../animation/markers.html) are used to denote frames with key points or significant events
within an animation. Like with most animation editors, they’re shown at the bottom.

[image reference removed]

Markers in animation editor.

There are some options that are exclusive to the Dope Sheet editor:

Sync Markers
:   Whether to also move the selected markers when moving the selected keyframes.

Show Pose Markers Action Editor
:   Instead of showing the global scene markers, show the local pose markers (which only exist inside the action).
    While this option is active, the *Add Marker* menu item will also create pose markers instead of scene markers.

Make Markers Local Action Editor
:   Converts the selected scene markers into pose markers,
    making them only visible inside the currently selected action.

For information about the other marker tools, see [Editing Markers](../../animation/markers.html#animation-markers-editing).
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Operation
:   The mathematical operator to be applied to the input values:

    Functions
    :   Add:
        :   The sum of the two values.

        Subtract:
        :   The difference between the two values.

        Multiply:
        :   The product of the two values.

        Divide:
        :   The division of the first value by the second value.

        Multiply Add:
        :   The sum of the product of the two values with *Addend*.

        Absolute:
        :   The input value is read without regard to its sign.
            This turns negative values into positive values.

        Negate:
        :   Changes the sign of the input value.

        Power:
        :   The *Base* raised to the power of *Exponent*.

    Comparison
    :   Minimum:
        :   Outputs the smallest of the input values.

        Maximum:
        :   Outputs the largest of two input values.

        Sign:
        :   Extracts the sign of the input value. All positive numbers
            will output 1. All negative numbers will output -1. And 0 will output 0.

    Rounding
    :   Divide Round:
        :   Divide the values and round the result toward zero.

        Divide Floor:
        :   Divide the values and floor the result down to the nearest integer.

        Divide Ceiling:
        :   Divide the values and ceil the result up to the nearest integer .

        Floored Modulo:
        :   Returns the positive remainder of a division operation.

        Modulo:
        :   Outputs the remainder once the first value is divided by the second value.

        Greatest Common Divisor:
        :   The largest positive integer that divides into each of the values.

        Least Common Multiple:
        :   The smallest positive integer that is divisible by both values.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The Curve modifier.

Curve Object
:   The name of the curve object that will affect the deformed object.

Deformation Axis
:   This is the axis that the curve deforms along.

    X/Y/Z/-X/-Y/-Z

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.
user: Explain FreestyleModules(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # FreestyleModules(bpy_struct)

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

*class* bpy.types.FreestyleModules(*bpy_struct*)
:   A list of style modules (to be applied from top to bottom)

    new()
    :   Add a style module to scene render layer Freestyle settings

        Returns:
        :   Newly created style module

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

    remove(*module*)
    :   Remove a style module from scene render layer Freestyle settings

        Parameters:
        :   **module** ([`FreestyleModuleSettings`](bpy.types.FreestyleModuleSettings.html#bpy.types.FreestyleModuleSettings "bpy.types.FreestyleModuleSettings"), (never None)) – Style module 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 BlenderRNA(bpy_struct), preserving all code examples.

assistant: # BlenderRNA(bpy_struct)

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

*class* bpy.types.BlenderRNA(*bpy_struct*)
:   Blender RNA structure definitions

    structs
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct"), (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: Explain ColorMixStrip(EffectStrip) in complete detail according to the official Blender documentation.

assistant: # ColorMixStrip(EffectStrip)

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

*class* bpy.types.ColorMixStrip(*EffectStrip*)
:   Color Mix Strip

    blend_effect
    :   Method for controlling how the strip combines with other strips

        Type:
        :   enum in [`'DARKEN'`, `'MULTIPLY'`, `'BURN'`, `'LINEAR_BURN'`, `'LIGHTEN'`, `'SCREEN'`, `'DODGE'`, `'ADD'`, `'OVERLAY'`, `'SOFT_LIGHT'`, `'HARD_LIGHT'`, `'VIVID_LIGHT'`, `'LINEAR_LIGHT'`, `'PIN_LIGHT'`, `'DIFFERENCE'`, `'EXCLUSION'`, `'SUBTRACT'`, `'HUE'`, `'SATURATION'`, `'COLOR'`, `'VALUE'`], default `'DARKEN'`

    factor
    :   Percentage of how much the strip’s colors affect other strips

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

    input_1
    :   First input for the effect strip

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

    input_2
    :   Second input for the effect strip

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Derivative of [limbs.paw](#limbs-paw) with extended IK suitable for use in front paws.
The additional IK limits the degree of change in the angle between shin and
paw bones (2nd and 3rd) as the main IK control moves and rotates.

For best results, the shin bone should not be parallel to either thigh or paw in rest pose,
i.e. there should be some degree of bend in all joints of the paw.

Heel IK Influence
:   Influence of the extended IK. At full rotating the main IK control or digit bone would
    not affect the rotation of the paw bone, while lower values provide some blending.
user: Explain VertexGroup(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # VertexGroup(bpy_struct)

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

*class* bpy.types.VertexGroup(*bpy_struct*)
:   Group of vertices, used for armature deform and other purposes

    index
    :   Index number of the vertex group

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

    lock_weight
    :   Maintain the relative weights for the group

        Type:
        :   boolean, default False

    name
    :   Vertex group name

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

    add(*index*, *weight*, *type*)
    :   Add vertices to the group

        Parameters:
        :   - **index** (*int array* *of* *1 items in* *[**-inf**,* *inf**]*) – List of indices
            - **weight** (*float in* *[**0**,* *1**]*) – Vertex weight
            - **type** (enum in [`'REPLACE'`, `'ADD'`, `'SUBTRACT'`]) –

              Vertex assign mode

              - `REPLACE`
                Replace – Replace.
              - `ADD`
                Add – Add.
              - `SUBTRACT`
                Subtract – Subtract.

    remove(*index*)
    :   Remove vertices from the group

        Parameters:
        :   **index** (*int array* *of* *1 items in* *[**-inf**,* *inf**]*) – List of indices

    weight(*index*)
    :   Get a vertex weight from the group

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index, The index of the vertex

        Returns:
        :   Vertex weight

        Return type:
        :   float in [0, 1]

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe Mask(ID) from the Blender manual or Python API, including usage steps and snippets.

assistant: # Mask(ID)

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

*class* bpy.types.Mask(*ID*)
:   Mask data-block defining mask for compositing

    active_layer_index
    :   Index of active layer in list of all mask’s layers

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

    animation_data
    :   Animation data for this data-block

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

    frame_end
    :   Final frame of the mask (used for sequencer)

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

    frame_start
    :   First frame of the mask (used for sequencer)

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

    layers
    :   Collection of layers which defines this mask

        Type:
        :   [`MaskLayers`](bpy.types.MaskLayers.html#bpy.types.MaskLayers "bpy.types.MaskLayers") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`MaskLayer`](bpy.types.MaskLayer.html#bpy.types.MaskLayer "bpy.types.MaskLayer"), (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: Show practical ways to work with Ambient Occlusion Node in a Blender add-on or script – include code.

assistant: # Ambient Occlusion Node

[image reference removed]

The *Ambient Occlusion* node computes how much the hemisphere above the shading point is occluded.
This can be used for procedural texturing, for example to add weathering effects to corners only.

For Cycles, this is an expensive shader and can slow down render significantly.
If render time is a concern, using Pointiness from the Geometry node or baking Ambient Occlusion will result
in faster renders.
user: Provide the full official documentation entry for Context Access (bpy.context), preserving all code examples.

assistant: # Context Access (bpy.context)

The context members available depend on the area of Blender which is currently being accessed.

Note that all context values are read-only,
but may be modified through the data API or by running operators.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Type
:   The type of angle input.

    X/Y/Z Axis:
    :   Rotates the vector around the defined axis and
        the amount of rotation is defined by the *Angle* input.

    Axis Angle:
    :   Rotates the vector around an arbitrary axis defined by the *Axis* input vector.
        The amount of rotation is defined by the *Angle* input.

    Euler:
    :   Rotates the vector about a center point defined by the *Center* input vector.
        The amount of rotation on each axis is defined by the *Rotation* input vector.

Invert
:   Inverts the rotation angle.
user: Provide the full official documentation entry for Screw Modifier, preserving all code examples.

assistant: # Screw Modifier

The *Screw* modifier is similar to the [Screw](../../meshes/editing/edge/screw.xhtml) tool
in the Toolbar, in that it takes a profile object, a mesh or a curve, to create a helix-like shape.

[image reference removed]

Properly aligning the profile object is important.

The profile should be properly aligned to the cardinal direction of the object rather than to the screw axis.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Curve
:   Standard geometry input with a curve component.

Radius
:   The radius of the circle portion generated at each fillet.

Count
:   Only in *Poly* mode, the number of control points to add for each fillet.

Limit Radius
:   Whether to limit the maximum value of the radius in order to avoid overlapping fillets.

Mode
:   How to choose number of vertices on fillet

    Bézier:
    :   Only two control points will be generated for every filleted control point. The shape generated
        by the aligned handles on the generated control points on either side of the fillet is used to
        create the circle portion shape, meaning that the number of segments in the fillet shape depends on
        the [spline’s resolution value](../read/spline_resolution.xhtml).

    Poly:
    :   The number of control points generated for each field
        input is controlled directly with an integer field input.
        This mode works better for poly and NURBS splines.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`AnnotationFrames.copy`](bpy.types.AnnotationFrames.html#bpy.types.AnnotationFrames.copy "bpy.types.AnnotationFrames.copy") - [`AnnotationFrames.copy`](bpy.types.AnnotationFrames.html#bpy.types.AnnotationFrames.copy "bpy.types.AnnotationFrames.copy") - [`AnnotationFrames.new`](bpy.types.AnnotationFrames.html#bpy.types.AnnotationFrames.new "bpy.types.AnnotationFrames.new") | - [`AnnotationFrames.remove`](bpy.types.AnnotationFrames.html#bpy.types.AnnotationFrames.remove "bpy.types.AnnotationFrames.remove") - [`AnnotationLayer.active_frame`](bpy.types.AnnotationLayer.html#bpy.types.AnnotationLayer.active_frame "bpy.types.AnnotationLayer.active_frame") - [`AnnotationLayer.frames`](bpy.types.AnnotationLayer.html#bpy.types.AnnotationLayer.frames "bpy.types.AnnotationLayer.frames") |
user: What is Splash Screen and how is it used in Blender Python scripting?

assistant: When Blender is configured for a particular studio or a project, it can be
helpful to customize the splash screen so artists know which version they
are running.

The `BLENDER_CUSTOM_SPLASH` [environment variable](command_line/arguments.xhtml#command-line-args-environment-variables)
replaces the entire splash image, while `BLENDER_CUSTOM_SPLASH_BANNER`
only overlays a banner.
user: Provide the full official documentation entry for Normalize All, preserving all code examples.

assistant: For each point, this tool makes sure that the sum of the weights across all vertex groups is equal to 1.
It normalizes all of the vertex groups, except for locked groups, which keep their weight values untouched.

Lock Active
:   Keep the values of the active group while normalizing all the others.
user: Show practical ways to work with Timer(bpy_struct) in a Blender add-on or script – include code.

assistant: # Timer(bpy_struct)

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

*class* bpy.types.Timer(*bpy_struct*)
:   Window event timer

    time_delta
    :   Time since last step in seconds

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

    time_duration
    :   Time since the timer started seconds

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

    time_step
    :   Type:
        :   float in [-inf, inf], default 0.0, (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 Usage, preserving all code examples.

assistant: The lattice should be scaled and moved to fit around your object in Object Mode.
Any scaling applied to the object in Edit Mode will result in the object deforming.
This includes applying its scale with `Ctrl`-`A` as this will achieve the same result as
scaling the lattice in Edit Mode, and therefore the object.

[image reference removed]

Lattice around the cube object in Object Mode.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`XrActionMaps.find`](bpy.types.XrActionMaps.html#bpy.types.XrActionMaps.find "bpy.types.XrActionMaps.find") - [`XrActionMaps.new`](bpy.types.XrActionMaps.html#bpy.types.XrActionMaps.new "bpy.types.XrActionMaps.new") - [`XrActionMaps.new_from_actionmap`](bpy.types.XrActionMaps.html#bpy.types.XrActionMaps.new_from_actionmap "bpy.types.XrActionMaps.new_from_actionmap") - [`XrActionMaps.new_from_actionmap`](bpy.types.XrActionMaps.html#bpy.types.XrActionMaps.new_from_actionmap "bpy.types.XrActionMaps.new_from_actionmap") - [`XrActionMaps.remove`](bpy.types.XrActionMaps.html#bpy.types.XrActionMaps.remove "bpy.types.XrActionMaps.remove") | - [`XrSessionState.action_binding_create`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.action_binding_create "bpy.types.XrSessionState.action_binding_create") - [`XrSessionState.action_create`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.action_create "bpy.types.XrSessionState.action_create") - [`XrSessionState.action_set_create`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.action_set_create "bpy.types.XrSessionState.action_set_create") - [`XrSessionState.actionmaps`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.actionmaps "bpy.types.XrSessionState.actionmaps") |
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Bundle
:   The resulting bundle that contains all items from the input bundles.

    Use the [Separate Bundle Node](separate_bundle.html) to access individual items from the combined bundle if needed.
user: How do I use Style Conventions in Blender? Include parameters, examples, warnings and best practices.

assistant: For Blender Python development we have chosen to follow Python suggested style guide to avoid mixing styles
among our own scripts and make it easier to use Python scripts from other projects.
Using our style guide for your own scripts makes it easier if you eventually want to contribute them to Blender.

This style guide is known as [pep8](https://www.python.org/dev/peps/pep-0008/)
and here is a brief listing of pep8 criteria:

- Camel caps for class names: MyClass
- All lower case underscore separated module names: my_module
- Indentation of 4 spaces (no tabs)
- Spaces around operators: `1 + 1`, not `1+1`
- Only use explicit imports (no wildcard importing `*`)
- Don’t use multiple statements on a single line: `if val: body`, separate onto two lines instead.

As well as pep8 we have additional conventions used for Blender Python scripts:

- Use single quotes for enums, and double quotes for strings.

  Both are of course strings, but in our internal API enums are unique items from a limited set, e.g:

  ```
  bpy.context.scene.render.image_settings.file_format = 'PNG'
  bpy.context.scene.render.filepath = "//render_out"
  ```
- pep8 also defines that lines should not exceed 79 characters,
  we have decided that this is too restrictive so it is optional per script.
user: How do I use Troubleshooting Windows – AMD in Blender? Include parameters, examples, warnings and best practices.

assistant: # Troubleshooting Windows – AMD

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: Describe Area Light from the Blender manual or Python API, including usage steps and snippets.

assistant: The area light simulates light originating from a surface (or surface-like) emitter.
For example, a TV screen, office neon lights, a window,
or a cloudy sky are just a few types of area light. The area light produces shadows with
soft borders by sampling a light along a grid the size of which is defined by the user.
This is in direct contrast to point-like artificial lights which produce sharp borders.

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

Shape
:   Shape of the light.

    Rectangle:
    :   The shape of the light can be represented as a rectangle and changed with the “X” and “Y” values.

    Square:
    :   The shape of the light can be represented as a square and changed with the *Size* property.

    Disk:
    :   The shape of the light can be represented as a disk and changed with the *Size* property.

    Ellipse:
    :   The shape of the light can be represented as an ellipse and changed with the X and Y values.

Size / Size X / Size Y
:   Dimensions for the *Square* or *Rectangle*.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

Metaball objects (short meta) are *implicit surfaces*,
meaning that they are *not explicitly* defined by vertices (as meshes are)
or control points (as surfaces are): they exist *procedurally*.
Meta objects are literally mathematical formulas that are calculated on-the-fly by Blender.

A very distinct visual characteristic of metas is that they are fluid *mercurial*,
or *clay-like* forms that have a “rounded” shape. Furthermore,
when two meta objects get close to one another, they begin to interact with one another.
They “blend” or “merge”, as water droplets do, especially in zero-g (which, by the way,
makes them very handy for modeling streams of water when you do not want to do a fluid simulation).
If they subsequently move away from one another, they restore their original shape.

Each of these is defined by its own underlying mathematical [structure](structure.xhtml),
and you can at any time switch between them using the *Active Element* panel.

Typically *Meta* objects are used for special effects or as a basis for modeling.
For example, you could use a collection of metas to form the initial shape of your model and
then convert it to a mesh for further modeling or sculpting. Meta objects are also very efficient for ray tracing.