PGCRYPT/OpenBlender_Train huggingface dataset:
user: What is ShaderNodeRGBCurve(ShaderNode) and how is it used in Blender Python scripting?

assistant: # ShaderNodeRGBCurve(ShaderNode)

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

*class* bpy.types.ShaderNodeRGBCurve(*ShaderNode*)
:   Apply color corrections for each color channel

    mapping
    :   Type:
        :   [`CurveMapping`](bpy.types.CurveMapping.html#bpy.types.CurveMapping "bpy.types.CurveMapping"), (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")

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: [image reference removed]

In the example above, we start with a grid of 1000x1000 square faces serving as “pixels.”
Then, we group these faces into patches by assigning them a group ID sampled from a Voronoi texture,
and move each resulting instance by a random amount along the Z axis.

Note that, because the texture outputs floating point values between 0 and 1 while the group ID
is an integer, all the values would be rounded to 0 or 1 and we would only get two groups.
To get more variation, we multiply the texture value by 1000.
user: Provide the full official documentation entry for Image Editor, preserving all code examples.

assistant: View Menu
:   After you render your scene with Stereo 3D you will be able to see
    the rendered result in the combined stereo 3D or to inspect the individual views.
    This works for Viewer nodes, render results or opened images.

    [image reference removed]

    Stereo 3D and view menu.

Views Format
:   When you drag and drop an image into the Image Editor, Blender will open it as an individual images at first.
    If your image was saved with one of the Stereo 3D formats, you can change how
    Blender should interpret the image by switching the mode to Stereo 3D,
    turning on *Use Multi-View* and picking the corresponding stereo method.

    [image reference removed]

    Views formats and stereo 3D.
user: Provide the full official documentation entry for GeometryNodeSetGreasePencilSoftness(GeometryNode), preserving all code examples.

assistant: # GeometryNodeSetGreasePencilSoftness(GeometryNode)

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

*class* bpy.types.GeometryNodeSetGreasePencilSoftness(*GeometryNode*)
:   Set softness attribute on Grease Pencil geometry

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Factor
:   Setting the factor allows you to add gravity to your brush strokes,
    giving it a draping effect.

Orientation
:   Using another object, the gravity can be oriented to the set object’s local Z axis,
    changing the direction of the gravity.
user: Provide the full official documentation entry for Annotation Layers, preserving all code examples.

assistant: When the annotation tool is enabled, the settings for managing multiple layers
can be found in the Sidebar ‣ View ‣ Annotations panel.

Opacity
:   Adjusts the opacity of existing and new strokes.

Thickness
:   Adjusts the thickness of existing and new strokes.

### Onion Skin

Shows a ghosted image of strokes made in frames before and after the current frame.
Onion skinning only works in the 3D Viewport and Sequencer.
See the Grease Pencil documentation for an explanation of
[Onion Skinning](../grease_pencil/properties/onion_skinning.xhtml).

Before/After
:   Color to use before and after the current frame on ghost frames.
    The number defines how many frames to show before and after the current frame.
user: Provide the full official documentation entry for GeometryNodeCustomGroup(GeometryNode), preserving all code examples.

assistant: # GeometryNodeCustomGroup(GeometryNode)

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

*class* bpy.types.GeometryNodeCustomGroup(*GeometryNode*)
:   Custom Geometry Group Node for Python nodes

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

    *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 Frame Sequence Workflow from the Blender manual or Python API, including usage steps and snippets.

assistant: 1. First prepare your animation.
2. In the *Format* panel, choose the render size, Pixel Aspect Ratio, and the Range of Frames to use,
   as well as the frame rate, which should already be set.
3. In the Output panel set up your animation to be rendered out as images,
   generally using a format that does not compromise any quality.
4. Choose the output path and file type in the Output panel as well, for example `//render/my-anim-`.
5. Confirm the range of your animation (frame Start and End).
6. Save your blend-file.
7. Press the *Animation* button and once the animation is finished,
   use your file manager to navigate to the output folder (`render` in this example).
   You will see lots of images that have a sequence number attached to. These are the single frames.
8. In Blender, open the [Video Sequencer](../../video_editing/index.html).
9. Choose *Add Image* from the add menu. Select all the frames from your output folder that you want to include
   in your animation. They will be added as a strip in the Sequence editor.
10. Now you can edit the strip and add effects or leave it like it is.
    You can add other strips, like an audio strip.
11. Scrub through the animation to check if you have included all the frames.
12. In the Output panel, choose the container and codec you want (e.g. `MPEG H.264`) and configure them.
    The video codecs are described in [Output Options](properties/output.html).
13. Click the *Animation* render button and Blender will render out the Sequence editor output into a movie.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: This API gives access the Blender’s internal mesh editing API, featuring geometry connectivity data and
access to editing operations such as split, separate, collapse and dissolve.
The features exposed closely follow the C API,
giving Python access to the functions used by Blender’s own mesh editing tools.

For an overview of BMesh data types and how they reference each other see:
[BMesh Design Document](https://developer.blender.org/docs/features/objects/mesh/bmesh/).
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Vertices
:   Number of vertices on the circle at the top and bottom.
    No geometry is generated if the number is below three.

Side Segments
:   Number of edges running vertically along the side of the cone.
    No geometry is generated if the number is below one.

Fill Segments
:   Number of concentric rings used to fill the round faces at the top and bottom.
    No geometry is generated if the number is below one.

Radius
:   Distance of the vertices from the Z axis.
    If this is zero, the output will be a single line.

Depth
:   Height of the cylinder.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [[image reference removed]](../../../_images/modeling_modifiers_deform_shrinkwrap_nearest-surface-point.png)

The Shrinkwrap modifier in Nearest Surface Point mode.

Wrap Method
:   This selector specifies the method to be used to determine the nearest
    point on the target’s surface for each vertex of the modified object.
    Some options will add some extra, specific controls to the panel.
    See [Wrap Methods](#wrap-methods) for an explanation of each method.

Snap Mode
:   Most modes support an additional setting to control how the vertex
    is moved to the target point selected by the methods described above.
    Some of the choices only differ if *Offset* is not zero.

    On Surface
    :   The vertex is always moved. The offset is applied along the projection line
        connecting the original vertex and selected target point towards the original position.

    Outside Surface
    :   Like *On Surface*, but the offset is always applied towards the outside of the target.

    Above Surface
    :   Like *On Surface*, but the offset is applied along the smooth normal of the target.

    Inside
    :   The vertex is not moved if it is already inside the target.
        Offset shrinks the allowed volume towards the inside along the projection line.

    Outside
    :   The vertex is not moved if it is already outside the target.
        Offset expands the exclusion volume towards the outside along the projection line.

Target
:   Shrink target, the mesh to shrink to/wrap around.

Offset
:   The distance that must be kept from the calculated target position.

Vertex Group
:   The vertex group to control whether and how much each vertex is displaced to its target position.
    If a vertex is not a member of this group, it is not displaced (same as weight 0).
user: How do I use ColorRampElement(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ColorRampElement(bpy_struct)

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

*class* bpy.types.ColorRampElement(*bpy_struct*)
:   Element defining a color at a position in the color ramp

    alpha
    :   Set alpha of selected color stop

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

    color
    :   Set color of selected color stop

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

    position
    :   Set position of selected color stop

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # GizmoGroupProperties(bpy_struct)

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

*class* bpy.types.GizmoGroupProperties(*bpy_struct*)
:   Input properties of a Gizmo Group

    bl_system_properties_get(*\**, *do_create=False*)
    :   DEBUG ONLY. Internal access to runtime-defined RNA data storage, intended solely for testing and debugging purposes. Do not access it in regular scripting work, and in particular, do not assume that it contains writable data

        Parameters:
        :   **do_create** (*boolean**,* *(**optional**)*) – Ensure that system properties are created if they do not exist yet

        Returns:
        :   The system properties root container, or None if there are no system properties stored in this data yet, and its creation was not requested

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

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

assistant: # Toolbar

Curve Edit Mode tools:

[Select](../../../interface/selecting.html#tool-select-tweak)
:   Select or move.

    [Select Box](../../../interface/selecting.html#tool-select-box)
    :   Select objects by dragging a box.

        All objects that intersect the box will be selected.

    [Select Circle](../../../interface/selecting.html#tool-select-circle)
    :   Select objects by dragging a circle. All objects that intersect the path of
        the circle will be selected.

    [Select Lasso](../../../interface/selecting.html#tool-select-lasso)
    :   Select objects by drawing a lasso.

Cursor
:   Change the location of the 3D Cursor.

Move
:   Translation tool.

Rotate
:   Rotation tool.

Scale
:   Scale tool.

    [Scale Cage](../../../scene_layout/object/tools/scale_cage.html#tool-scale-cage)
    :   Change the scale of an object by controlling its cage.

Transform
:   Tool to adjust the objects translation, rotations and scale.

[Annotate](../../../interface/annotate_tool.html#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../../interface/annotate_tool.html#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../../interface/annotate_tool.html#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../../interface/annotate_tool.html#tool-annotate-eraser)
    :   Erase previous drawn annotations.

[Measure](../../../editors/3dview/toolbar/measure.html#tool-measure)
:   Measure distances in the scene.

[Draw](draw.html#bpy-ops-curve-draw)
:   Free-hand drawing of new curves.

[Curve Pen](pen.html#bpy-ops-curve-pen)
:   Construct and edit splines.

[Extrude](../editing/control_points.html#modeling-curves-extrude)
:   Extrude the curve by adding new control points.

[Radius](../editing/curve.html#modeling-curve-radius)
:   Control the radius value of the control points.

[Tilt](../editing/control_points.html#modeling-curve-tilt)
:   Control the rotation value of the control points around the curve’s axis.

Randomize
:   Move selected control points in pseudo-random directions.
user: Describe Driver Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Type

There are two categories of drivers:

- **Built-in functions** (*Average*, *Sum*, *Min* and *Max*)

  The driven property will have the value of the average, sum, lowest or highest (respectively)
  of the values of the referenced *Driver Variables*.
  If there is only one driver variable, these functions will yield the same result.
- **Custom** (*Scripted Expression*).

  An arbitrary Python expression that can refer to the *Driver Variables* by name. See [Expressions](#expressions).

### Driver Value

The current result of the driver setup. Useful for debug purposes.

### Variables

See [Driver Variables](#driver-variables).

### Update Dependencies

Forces an update for the Driver Value dependencies.

### Show in Drivers Editor

Opens the fully featured [Drivers Editor](../../editors/drivers_editor.xhtml).
This button only appears in the popover version of the Drivers panel.
user: Give a detailed overview of What is an Asset Library?: syntax, arguments, return values, common patterns.

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

[image reference removed]

Name and Location of asset libraries in the Preferences.

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

The blend-files can be directly in the top-level directory of the asset library, or in any subdirectory.
The on-drive organization of asset libraries is all up to you. Regardless of which blend-file contains the assets,
each asset can be assigned a **catalog**. For more info about how to organize your assets
this way, see [Asset Catalogs](catalogs.html).
user: How do I use Bpy.Types.Themenodeeditor in Blender? Include parameters, examples, warnings and best practices.

assistant: odeEditor.grid_levels ThemeNodeEditor.group_node ThemeNodeEditor.group_socket_node ThemeNodeEditor.input_node ThemeNodeEditor.matte_node ThemeNodeEditor.node_active ThemeNodeEditor.node_backdrop ThemeNodeEditor.node_outline ThemeNodeEditor.node_selected ThemeNodeEditor.noodle_curving ThemeNodeEditor.output_node ThemeNodeEditor.repeat_zone ThemeNodeEditor.script_node ThemeNodeEditor.shader_node ThemeNodeEditor.simulation_zone ThemeNodeEditor.space ThemeNodeEditor.texture_node ThemeNodeEditor.vector_node ThemeNodeEditor.wire ThemeNodeEditor.wire_inner ThemeNodeEditor.wire_select ThemeNodeEditor.bl_rna_get_subclass() ThemeNodeEditor.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Value
:   A float or vector value that is relative to the image size and should be converted to pixels.

Image
:   The image used to determine the resolution for the conversion. This defines the reference size
    used for computing pixel values.
user: Explain Bounding Box Node in complete detail according to the official Blender documentation.

assistant: # Bounding Box Node

[image reference removed]

The *Bounding Box* node creates a box mesh with the minimum volume that encapsulates
the geometry of the input. The node also can output the vector positions of the bounding dimensions.

The mesh output and the *Min* and *Max* outputs do not take instances into account. Instead,
for instanced geometry, a bounding box is computed for each instance rather than the whole geometry.
To compute the bounding box including the instances,
a [Realize Instances Node](../../instances/realize_instances.html) can be used.
user: Give a detailed overview of Built-in Color Spaces: syntax, arguments, return values, common patterns.

assistant: Blender’s OCIO configuration file is equipped by default to read/write files in these color spaces

### Display

Color spaces for displays and image files.

sRGB:
:   Standard RGB display space using Rec. 709 chromaticities and a D65 white point.

Rec.2020:
:   BT.2020 2.4 Exponent EOTF Display.

Rec.1886:
:   BT.1886 2.4 Exponent EOTF Display, commonly used for TVs.

Display P3:
:   Apple’s Display P3 with sRGB compound (piece-wise) encoding transfer function, common on Mac devices.

Rec.2100 PQ:
:   For high dynamic range images and video with Rec.2020 wide gamut, up to 10000 nits.

Rec.2100 HLG:
:   For high dynamic range images and video with Rec.2020 wide gamut, up to 1000 nits.

### Linear

Color spaces commonly used for OpenEXR files.

Working Space:
:   The linear working space of the current blend file,
    that is used by default in compositing, shader and geometry nodes.

Linear Rec.709:
:   Linear BT.709 chromaticities with illuminant D65 white point.

Linear Rec.2020:
:   Linear BT.2020 with illuminant D65 white point.

ACEScg:
:   An ACES color space that is designed to be used for rendering and compositing.
    It uses the AP1 color primaries, a D60 white point, and a linear transfer function.
    The standard working space in ACES workflows.

ACES2065-1:
:   An ACES color space using the AP0 color primaries, a D60 white point and a linear transfer function.
    This color space is meant to store and transfer data, preserving the most information possible.
    Commonly used for delivery and archival in ACES workflows.

Linear FilmLight E-Gamut:
:   Linear E-Gamut with illuminant D65 white point.

Linear DCI-P3 D65:
:   Linear DCI-P3 with illuminant D65 white point.

Linear CIE-XYZ E:
:   1931 CIE XYZ standard with assumed illuminant E white point.

Linear CIE-XYZ D65:
:   1931 CIE XYZ with adapted illuminant D65 white point.

### Other

Non-Color:
:   Generic data that is not color, will not apply any color transform (e.g. normal maps or displacement maps).

Working Space:
:   Uses the [File](#bpy-types-blendfilecolorspace-working-space)
    color space defined in the scene’s color management settings.

### Log

ACEScc:
:   ACES color correction space, using AP1 primaries.

ACEScct:
:   ACES color correction space with toe, using AP1 primaries.

AgX Log:
:   Intermediate log color space of AgX view transform.

Filmic Log:
:   Intermediate log color space of Filmic view transform.

### Utilities

Color spaces corresponding to view transforms. These color spaces can
be used for background images that should not be affected by the view
transform, while everything else in the scene is affected.

ACES 1.3 sRGB:
:   ACES 1.3 view transform

ACES 2.0 sRGB:
:   ACES 2.0 view transform

AgX Base sRGB:
:   AgX view transform

Filmic sRGB:
:   Filmic view transform

Khronos PBR Neutral sRGB:
:   Khronos PBR Neutral view transform
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Properties should be documented using definition lists. Properties that are hidden based on other properties should
used nested definitions:

```
Property
   Property description.

   Hidden Property
      Hidden property description.
```

Select menus should be documented using the following syntax:

```
Menu Label
   General description of the menu.

   :Menu Item: Menu Item Definition.
   :Menu Item: Menu Item Definition.
   :Menu Item: Menu Item Definition.
```
user: Describe WipeStrip(EffectStrip) from the Blender manual or Python API, including usage steps and snippets.

assistant: # WipeStrip(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.WipeStrip(*EffectStrip*)
:   Sequence strip creating a wipe transition

    angle
    :   Angle of the transition

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

    blur_width
    :   Width of the blur for the transition, in percentage relative to the image size

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

    direction
    :   Whether to fade in or out

        Type:
        :   enum in [`'OUT'`, `'IN'`], default `'OUT'`

    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)

    transition_type
    :   Type:
        :   enum in [`'SINGLE'`, `'DOUBLE'`, `'IRIS'`, `'CLOCK'`], default `'SINGLE'`

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

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

Object
:   Used to select the object to which the plane track is linked.

Track
:   Used to select the plane track to use.
user: Give a detailed overview of Limitations: syntax, arguments, return values, common patterns.

assistant: - Viewer and inspection nodes may not display accurate values when closures are evaluated in multiple contexts.
- Captured external values are read-only and cannot be modified inside the evaluation.
- Closures currently cannot access attributes or data outside their evaluation context.
user: What is Wayland and how is it used in Blender Python scripting?

assistant: Support for Wayland is a more recent addition, so there may be configurations that have not been tested yet. Please
[report a bug](../../troubleshooting/report_bug.xhtml) if you experience problems.

Blender has been tested with Gnome-Shell (mutter), KDE (plasma) & SWAY (wlroots) based compositors.

### Requirements

Gnome-Shell
:   Under Gnome-Shell the `libdecor` library is required. This is available as a package on most Linux distribution.

    If the library isn’t found X11 will be used as a fallback.

### Troubleshooting

Detailed Wayland output can help to track down problems. Launch Blender from the
[command-line](../../advanced/command_line/launch/linux.xhtml) with additional arguments:

Blender’s Wayland Logging
:   ```
    blender --log "ghost.wl.*" --log-level 2
    ```

Wayland Built-In Logging
:   ```
    WAYLAND_DEBUG=1 blender
    ```

Disable Wayland (forcing X11)
:   ```
    WAYLAND_DISPLAY="" blender
    ```

Disable `libdecor` (forcing borderless windows under Gnome-Shell)
:   Uninstall `libdecor`, then run Blender with an empty X11 display variable.

    ```
    DISPLAY="" blender
    ```

### Environment Variables

`XCURSOR_THEME`
:   The cursor theme to use (must refer to a locally installed cursor).

`XCURSOR_SIZE`
:   The cursor size, defaults to 28, you may wish to increase the size on Hi-DPI displays.

### Known Limitations

Gnome Shell’s Fractional Scaling (before version 44)
:   Versions of Gnome-Shell prior to 44 don’t fully support fractional scaling.

    Using fractional under older versions of Gnome-Shell may result in glitches such as a [small cursor size](https://projects.blender.org/blender/blender/issues/105895).

NVIDIA GPU
:   Currently NVIDIA drivers don’t fully support features needed for Wayland. Graphical glitches and flickering are
    common problems. In some cases, there can be [crashes on startup](https://projects.blender.org/blender/blender/issues/103999). This is not specific to Blender, so NVIDIA users
    may want to use X11 until driver support improves.

---
user: Give a detailed overview of Scale Cage: syntax, arguments, return values, common patterns.

assistant: # Scale Cage

The *Scale Cage* tool is a bounding box around the object(s) which scales objects from a particular point or axis.
The tool works by selecting a scale point and dragging inwards or outwards to adjust the scale accordingly.
The origin for the scale will be from the point on the cube directly opposite from the point selected.
Selecting points on the faces of the cube scales along one axis,
selecting points on the edges of the cube scales along two axes,
and selecting points on the vertices of the cube scales along all three axes.

[image reference removed]

Scale Cage tool.
user: Describe NodeTreeInterfaceSocketFloatPercentage(NodeTreeInterfaceSocket) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeTreeInterfaceSocketFloatPercentage(NodeTreeInterfaceSocket)

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

*class* bpy.types.NodeTreeInterfaceSocketFloatPercentage(*NodeTreeInterfaceSocket*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

    *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 CompositorNodeRLayers(CompositorNode) in complete detail according to the official Blender documentation.

assistant: # CompositorNodeRLayers(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.CompositorNodeRLayers(*CompositorNode*)
:   Input render passes from a scene render

    layer
    :   Type:
        :   enum in [`'PLACEHOLDER'`], default `'PLACEHOLDER'`

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

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

assistant: Select geometry connected to already selected elements.
This is often useful when a mesh has disconnected, overlapping parts,
where isolating it any other way would be tedious.
Pressing `Shift`-`L` will deselect linked any linked elements.

With `L` you can also select connected geometry directly under the cursor.
user: What is LineStyleColorModifier_Tangent(LineStyleColorModifier) and how is it used in Blender Python scripting?

assistant: # LineStyleColorModifier_Tangent(LineStyleColorModifier)

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"), [`LineStyleColorModifier`](bpy.types.LineStyleColorModifier.html#bpy.types.LineStyleColorModifier "bpy.types.LineStyleColorModifier")

*class* bpy.types.LineStyleColorModifier_Tangent(*LineStyleColorModifier*)
:   Change line color based on the direction of a stroke

    blend
    :   Specify how the modifier value is blended into the base value

        Type:
        :   enum in [Ramp Blend Items](bpy_types_enum_items/ramp_blend_items.html#rna-enum-ramp-blend-items), default `'MIX'`

    color_ramp
    :   Color ramp used to change line color

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Color Modifier Type Items](bpy_types_enum_items/linestyle_color_modifier_type_items.html#rna-enum-linestyle-color-modifier-type-items), default `'ALONG_STROKE'`, (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.LineStyleColorModifier_Tangent.type "bpy.types.LineStyleColorModifier_Tangent.type")
user: How do I use GeometryNodeConvexHull(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeConvexHull(GeometryNode)

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

*class* bpy.types.GeometryNodeConvexHull(*GeometryNode*)
:   Create a mesh that encloses all points in the input geometry with the smallest number of points

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: The purpose of these operators is to reduce or enlarge the current selection within a stroke
(i.e. they will never “go outside” of a stroke or “jump” to another stroke in the same object).

More
:   For each selected point, select *all* its linked points (i.e. one or two…).

Less
:   For each selected point, if *all* points linked to this point are selected, keep this one selected.
    Otherwise, deselect it.
user: Provide the full official documentation entry for GPU Module (gpu), preserving all code examples.

assistant: # GPU Module (gpu)

This module provides Python wrappers for the GPU implementation in Blender.
Some higher level functions can be found in the [`gpu_extras`](gpu_extras.html#module-gpu_extras "gpu_extras") module.
user: How do I use Float2Attribute(Attribute) in Blender? Include parameters, examples, warnings and best practices.

assistant: # Float2Attribute(Attribute)

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

*class* bpy.types.Float2Attribute(*Attribute*)
:   Geometry attribute that stores floating-point 2D vectors

    data
    :   Type:
        :   [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`Float2AttributeValue`](bpy.types.Float2AttributeValue.html#bpy.types.Float2AttributeValue "bpy.types.Float2AttributeValue"), (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 Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: Effector Type
:   Collision:
    :   Objects of this type will collide with fluid.

    Guide:
    :   The velocity of objects of this type will be used when baking the guiding.
        So fluid guiding objects should move and have some velocity.

        Velocity Factor
        :   Multiply the guiding object velocities by this factor. This is useful when working with
            multiple guiding objects and some of them should have higher or smaller velocities.

        Guide Mode
        :   The mode describes how guiding velocities should be written into the global guiding velocity
            field of the domain.

            Maximize:
            :   The guiding object will compare the existing velocity in the global velocity field with
                its own velocity. If its absolute value is greater than the absolute value in the velocity
                field the guiding velocity will be kept.

            Minimize:
            :   A guiding object will compare the existing velocity in the global velocity field with its
                own velocity. If its absolute value is smaller than the absolute value in the velocity
                field the guiding velocity will be kept.

            Override:
            :   The most intuitive option. A guiding object will always
                write its own current velocity into the global guiding velocity field.
                Values in the velocity field from a previous frame or guiding object
                will be overridden.

            Averaged:
            :   A guiding object will write the average of its own current velocity and the existing
                guiding velocity at that cell into the global guiding velocity field.

Sampling Substeps
:   Number of substeps used to reduce gaps in collision of fluid from fast-moving effectors.

Surface Thickness
:   Additional area around the effector that will be considered as an effector.

Use Effector
:   Enables or disables the effector object effect on the fluid,
    this property is useful for animations to selectively enable and disable
    when the effector affects the fluid.

Is Planar
:   Defines the effector as either a single dimension object i.e. a plane or the mesh is [Non-manifold](../../../glossary/index.html#term-Non-manifold).
    This ensures that the fluid simulator will give the most accurate results for these types of meshes.

    A [Manifold](../../../glossary/index.html#term-Manifold) mesh can also be declared as planar. The fluid solver will then ignore the volume
    inside the mesh and just emit fluid from the mesh sides.
user: How do I use NodesModifierBakes(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodesModifierBakes(bpy_struct)

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

*class* bpy.types.NodesModifierBakes(*bpy_struct*)
:   Bake data for every bake node

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

assistant: ### General

Hardness
:   Slightly higher by default. This makes the profile of the brush more noticeable.
    More info at [Hardness](../../brush/brush_settings.html#bpy-types-brush-hardness)

Auto-Smooth
:   Enabled by default for a consistent smoothing effect.
    With lower brush strength (for example with lower pen pressure) the smoothing effect will be more noticeable
    and can be used to create and then blend/polish shapes in a single stroke.
    Enable Pressure to modulate the use of auto-smooth even more with pen inputs.
    More info at [Auto-Smooth](../../brush/brush_settings.html#bpy-types-brush-auto-smooth-factor)