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

assistant: High Quality
:   Uses more precise math to better determine the locations for the objects.
    In case of positive or negative bounding box alignment,
    if one or more of the selected objects have any rotation transformations
    (or delta rotation transformations), it is recommended to check *High Quality*
    so that their bounding box is calculated with precision for all three global axes.

Align Mode
:   The *Align Mode* control will define what part of the objects will be aligned:

    Centers:
    :   The objects centers.

    Positive Sides/Negative Sides:
    :   The positive or negative sides (on the global axes) of their respective bounding boxes.

Relative To
:   The *Relative To* control will let us choose to align the objects to:

    Active:
    :   The active object.

    Selection:
    :   The median point of the selection.

    3D Cursor:
    :   The current position of the 3D Cursor.

    Scene Origin:
    :   The global origin.

Align X, Y, Z
:   Chooses which axis to align the selected objects on.
user: Explain Examples in complete detail according to the official Blender documentation.

assistant: Below are some common curves you can use to achieve desired effects.

[[image reference removed]](../../../_images/compositing_types_color_rgb-curves_example-common-use.png)

From left to right: 1. Lighten shadows 2. Negative 3. Decrease contrast 4. Posterize.

### Color Correction using Curves

[[image reference removed]](../../../_images/compositing_types_color_rgb-curves_example-rgb.png)

Color correction with curves.

In this example, the image has too much red in it,
so we run it through an *RGB Curves* node and reduce the Red channel.

The documentation for the [Mix Color Node](../../../compositing/types/color/mix_color.html) has an additional
example about fixing overexposure.

### Color Correction using Black/White Levels

[[image reference removed]](../../../_images/compositing_types_color_rgb-curves_black-white-levels.png)

Color correction with Black/White Levels.

Manually adjusting the RGB curves for color correction can be difficult.
Another option for color correction is to use the Black and White Levels instead,
which really might be their main purpose.

In this example,
the White Level is set to the color of a bright spot of the sand in the background,
and the Black Level to the color in the center of the fish’s eye.
To do this efficiently it is best to bring up the Image Editor showing the original input image.
You can then use the levels’ color picker to easily choose
the appropriate colors from the input image, zooming into pixel level if necessary.
The result can be fine-tuned with the R, G, and B curves like in the previous example.

The curve for C is used to compensate for the increased contrast that is a side effect of
setting Black and White Levels.

### Effects

[[image reference removed]](../../../_images/compositing_types_color_rgb-curves_ex.png)

Changing colors by inverting the red channel.
user: Provide the full official documentation entry for LineStyleAlphaModifier_Noise(LineStyleAlphaModifier), preserving all code examples.

assistant: # LineStyleAlphaModifier_Noise(LineStyleAlphaModifier)

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

*class* bpy.types.LineStyleAlphaModifier_Noise(*LineStyleAlphaModifier*)
:   Alpha transparency based on random noise

    amplitude
    :   Amplitude of the noise

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

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

        Type:
        :   enum in [`'MIX'`, `'ADD'`, `'SUBTRACT'`, `'MULTIPLY'`, `'DIVIDE'`, `'DIFFERENCE'`, `'MINIMUM'`, `'MAXIMUM'`], default `'MIX'`

    curve
    :   Curve used for the curve mapping

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

    invert
    :   Invert the fade-out direction of the linear mapping

        Type:
        :   boolean, default False

    mapping
    :   Select the mapping type

        - `LINEAR`
          Linear – Use linear mapping.
        - `CURVE`
          Curve – Use curve mapping.

        Type:
        :   enum in [`'LINEAR'`, `'CURVE'`], default `'LINEAR'`

    period
    :   Period of the noise

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

    seed
    :   Seed for the noise generation

        Type:
        :   int in [1, 32767], default 0

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Alpha Modifier Type Items](bpy_types_enum_items/linestyle_alpha_modifier_type_items.html#rna-enum-linestyle-alpha-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.LineStyleAlphaModifier_Noise.type "bpy.types.LineStyleAlphaModifier_Noise.type")
user: Provide the full official documentation entry for Split, preserving all code examples.

assistant: The *Split* operator separates the selected portion of a curve from the rest,
creating a new, independent curve segment.
This curve can then be moved or altered without affecting the other curve.

- If a segment of the curve is selected, it will be split off
  as a new curve that can be moved or edited independently.
- If only a single control point is selected, it will be duplicated as a loose control point,
  while the original remains attached to the rest of the curve.
user: Show practical ways to work with Object Origin in a Blender add-on or script – include code.

assistant: # Object Origin

Each object has an origin point. The location of this point determines where the object is located in 3D space.
When an object is selected, a small dot appears, denoting the origin point.
The location of the origin point is important when translating, rotating or scaling an object.
See [Pivot Points](../../editors/3dview/controls/pivot_point/index.xhtml) for more.

The color of the origin changes based on the [selection](selecting.xhtml)
state of the object.

Yellow:
:   Object is active.

Orange:
:   Object is selected, but not active.

White:
:   Object is not linked and not selected.

Turquoise:
:   Object is linked.

Light Turquoise:
:   Object is selected, linked, but not active.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Image
:   Standard color input.

Type
:   The direction of convert alpha.
    For details on the difference between both ways to store alpha values see [Alpha Channel](../../../glossary/index.html#term-Alpha-Channel).

    To Premultiplied:
    :   Converts from [Straight Alpha](../../../glossary/index.html#term-Straight-Alpha) to [Premultiplied Alpha](../../../glossary/index.html#term-Premultiplied-Alpha).

    To Straight:
    :   Converts from [Premultiplied Alpha](../../../glossary/index.html#term-Premultiplied-Alpha) to [Straight Alpha](../../../glossary/index.html#term-Straight-Alpha).
user: Show practical ways to work with UDIM Tiles in a Blender add-on or script – include code.

assistant: In this panel UDIM tiles are managed;
new tiles can be added, tiles can be removed, or tiles can filled with a generated texture.

UDIM Tile List
:   List all UDIM tiles associated with the main index (`1000` tile).
    Double clicking on the tile name allows you to alter the tiles *Label*.

Add Tile
:   Adds new UDIM tiles to the group.

    Number
    :   The starting tile index number.
        UDIMs must start with the `1001` tile and typically increase in incremental order.

    Count
    :   The number of tiles to add.

    Label
    :   An optional label can be used instead of the index number.
        These labels are shown in the 2D Viewport.

    Fill
    :   Occupy the UDIM tile with a generated image; see *Fill Tile* below.

Remove Tile
:   Deletes the selected UDIM tile from the group.
    If this tile is not saved and contains data, that data will be lost.

Fill Tile
:   Occupy the UDIM tile with a [Generated Image](../../../../editors/image/image_settings.xhtml#image-generated).
user: Provide the full official documentation entry for Select Random, preserving all code examples.

assistant: Select Random control points.

Percent
:   Selects the defined percentage of control points.

Random Seed
:   [Seed](../../glossary/index.html#term-Seed) used by the pseudo-random number generator.

Action
:   Controls whether the operator *Selects* or *Deselects* control points.
user: Provide the full official documentation entry for Select Edge Ring, preserving all code examples.

assistant: Holding `Ctrl`-`Alt` while clicking an edge selects that edge and then expands the selection
as far as possible in the two directions perpendicular to it. (While this of course works for selecting
edge “rings” that go all the way around a mesh, it also works if there’s no ring.)

You can additionally hold `Shift` to extend the current selection rather than replacing it.
user: What is Simulation Nodes and how is it used in Blender Python scripting?

assistant: # Simulation Nodes

Through the use of [Simulation Zones](../modeling/geometry_nodes/simulation/simulation_zone.html),
[Geometry Nodes](../modeling/geometry_nodes/index.html) can be used to create custom physic simulations through nodes.
Simulation zones allow the result of one frame to influence the next one.
That way even a set of simple rules can lead to complex results, with the passing of time.
The most common type of them is physics simulation, with specific solvers for physical phenomena.
user: What is GeometryNodeMergeLayers(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeMergeLayers(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.GeometryNodeMergeLayers(*GeometryNode*)
:   Join groups of Grease Pencil layers into one

    mode
    :   Determines how to choose which layers are merged

        - `MERGE_BY_NAME`
          By Name – Combine all layers which have the same name.
        - `MERGE_BY_ID`
          By Group ID – Provide a custom group ID for each layer and all layers with the same ID will be merged into one.

        Type:
        :   enum in [`'MERGE_BY_NAME'`, `'MERGE_BY_ID'`], default `'MERGE_BY_NAME'`

    *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 Is Face Planar Node and how is it used in Blender Python scripting?

assistant: # Is Face Planar Node

[image reference removed]

The *Is Face Planar* node outputs whether every triangle of a
[quads](../../../../glossary/index.xhtml#term-Quad) or [N-gons](../../../../glossary/index.xhtml#term-N-gon) is on the same plane as all of the others, in
other words, if they have the same [normal](../../../meshes/editing/mesh/normals.xhtml).

For example, a non-planar face can be created by moving a single vertex in a face but not
the others. Triangles will always be planar.
user: How do I use Hair Curves Noise in Blender? Include parameters, examples, warnings and best practices.

assistant: # Hair Curves Noise

The *Hair Curves Noise* node adds procedural noise-based deformation to hair curves,
creating natural-looking randomness or turbulence.
This can be used to simulate effects such as wind disturbance, curly or wavy hair,
or subtle irregularities in a groom.
user: Describe CompositorNodeDBlur(CompositorNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CompositorNodeDBlur(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.CompositorNodeDBlur(*CompositorNode*)
:   Blur an image along a direction

    *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 Set Handle Positions Node: syntax, arguments, return values, common patterns.

assistant: # Set Handle Positions Node

[image reference removed]

The *Set Handle Positions* node sets the positions for the handles of [Bézier curves](../../../curves/structure.html#curve-bezier).
They can be used to alter the generated shape of the curve.
The input node for this data is the [Curve Handle Positions Node](../read/curve_handle_positions.html).
See the [Bézier curves](../../../curves/structure.html#curve-bezier-handle-type) page for more details.
user: Provide the full official documentation entry for Anonymous Attributes, preserving all code examples.

assistant: [image reference removed]

The *Normal* and *Rotation* outputs are examples of attribute fields,
which refer to an attribute stored on a geometry.

An anonymous attribute is a set of generic data stored on a geometry that doesn’t have a name.
Usually, attributes exposed in Blender’s interface all have names. However,
in geometry nodes, attributes can be passed around with node sockets.
In these cases, an *Attribute Field* output is created, which is used by
nodes to find attribute data in an input geometry.

Anonymous attributes are still stored on the geometry like other attributes, and they are even
automatically interpolated when the geometry changes with other nodes, except for a few cases.
So generally, if the node link is still accessible, the attribute it references will be available
too. However, anonymous attributes cannot be connected to a completely separate geometry
that was created from a different source. To transfer attributes between separate geometries,
the [Sample Index Node](geometry/sample/sample_index.xhtml) or other similar nodes like the
[Sample Nearest Surface Node](mesh/sample/sample_nearest_surface.xhtml) can be used.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`WindowManager.popmenu_begin__internal`](bpy.types.WindowManager.html#bpy.types.WindowManager.popmenu_begin__internal "bpy.types.WindowManager.popmenu_begin__internal") | - [`WindowManager.popmenu_end__internal`](bpy.types.WindowManager.html#bpy.types.WindowManager.popmenu_end__internal "bpy.types.WindowManager.popmenu_end__internal") |
user: What is NodeSocketBool(NodeSocketStandard) and how is it used in Blender Python scripting?

assistant: # NodeSocketBool(NodeSocketStandard)

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

*class* bpy.types.NodeSocketBool(*NodeSocketStandard*)
:   Boolean value socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   boolean, default False

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

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

        (readonly)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Popup Menus in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Image menu in the Header of the Image editor.

Popup menus list [Operators](../../operators.xhtml) which can be executed by selecting with `LMB`
or using the generated shortcut indicated by the underlined character of the operator name.
All menu entries show any relevant shortcut keys, which can be executed without opening the menu.

All popup menus can be searched by pressing `Spacebar` and typing the name of the operator in the menu.
If a popup menu has “Search” as one of the items, the menu can be searched without having to press `Spacebar`
first.

All popup menus of an editor can be searched using the [Menu Search](../../operators.xhtml#bpy-ops-wm-search-menu) feature.

### Collapsing Menus

Sometimes it’s helpful to gain some extra horizontal space in the header by collapsing menus.
This can be accessed from the header context menu:
click `RMB` on the header and uncheck the *Show Menus checkbox*.

|  |  |
| --- | --- |
| ../../../_images/interface_controls_buttons_menu_header_uncheck_show_menus_checkbox.png   Right-click on any of the header menus. | ../../../_images/interface_controls_buttons_menus_header-menu-collapsed.png   Access the menu from the collapsed icon. |
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Evaluate Closure* node is typically used to make a node group partially customizable while maintaining a stable,
reusable framework.

For example, a terrain generator might use *Evaluate Closure* to define how trees are distributed across a landscape:

1. Inside the generator group, replace the fixed tree placement logic with an *Evaluate Closure* node.
2. Expose the closure input on the group’s interface.
3. In the main node tree, connect a *Closure Zone* defining the desired tree distribution behavior.

Whenever the closure is evaluated, the connected node graph runs within the terrain generator’s context, producing a
customized result.

[image reference removed]

Example: custom tree distribution using *Evaluate Closure*.
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Corner Index
:   The geometry-wide index of the selected corner. You can pass this to the
    [Evaluate at Index Node](../../utilities/field/evaluate_at_index.xhtml) or the
    [Sample Index Node](../../geometry/sample/sample_index.xhtml) (with the domain set to Face Corner)
    to retrieve details about the corner.

Total
:   The number of adjacent corners, which is also the number of faces.
user: What is Examples and how is it used in Blender Python scripting?

assistant: You can do just about anything with images using nodes.

Raw footage from a foreground actor in front of a blue screen,
or a rendered object doing something, can be layered on top of a background.
Composite both together, and you have composited footage.

You can change the mood of an image:

- To make an image ‘feel’ colder, a blue tinge is added.
- To convey a flashback or memory, the image may be softened.
- To convey hatred and frustration, add a red tinge or enhance the red.
- A startling event may be sharpened and contrast-enhanced.
- To convey a happy feeling add yellow (equal parts red and green, no blue).
- Dust and airborne dirt are often added as a cloud texture over the image to give a little more realism.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: The *Main Geometry* outputs create attributes on the “main” output geometry (the first output).
Every single value on the inside of the zone becomes a value of the attribute at the current index.

The outputs in the *Generated* panel, including the default *Geometry* output are joined together from the
geometry generated from each element. Any non-geometry type below a specific geometry in this list will output
as an [anonymous attribute](../attributes_reference.xhtml#anonymous-attributes) on that joined geometry (and not the others).
Attributes from the zone’s input geometry are also propagated to these geometry outputs.
user: Explain Radius Node in complete detail according to the official Blender documentation.

assistant: # Radius Node

[image reference removed]

The *Radius* node outputs the radius value at each point on the evaluated geometry.
For curves, this value is used for things like determining the size of the mesh created in
the [Curve to Mesh](../../curve/operations/curve_to_mesh.xhtml) node.
For point clouds, the value is used for the display size of the point in the viewport.
user: Provide the full official documentation entry for Compositor, preserving all code examples.

assistant: # Compositor

The Compositor lets you manage [nodes](../interface/controls/nodes/index.html)
for compositing.

[image reference removed]

Nodes in the Compositor.

The use of the Compositor is explained in [Compositing](../compositing/index.html).
user: How do I use VertexGroups(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # VertexGroups(bpy_struct)

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

*class* bpy.types.VertexGroups(*bpy_struct*)
:   Collection of vertex groups

    active
    :   Vertex groups of the object

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

    active_index
    :   Active index in vertex group array

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

    new(*\**, *name='Group'*)
    :   Add vertex group to object

        Parameters:
        :   **name** (*string**,* *(**optional**,* *never None**)*) – Vertex group name

        Returns:
        :   New vertex group

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

    remove(*group*)
    :   Delete vertex group from object

        Parameters:
        :   **group** ([`VertexGroup`](bpy.types.VertexGroup.html#bpy.types.VertexGroup "bpy.types.VertexGroup"), (never None)) – Vertex group to remove

    clear()
    :   Delete all vertex groups from object

    *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 Options and how is it used in Blender Python scripting?

assistant: [image reference removed]

The Build modifier.

Start Frame
:   The start frame of the building process.

Length
:   The number of frames over which to rebuild the object.

Reversed
:   The modifier will operate in reverse, essentially allowing it to be used as a “deconstruction” effect.
    This is useful for making a set of instancing objects gradually disappear.

### Randomize

Randomizes the order in which the faces are built.

Seed
:   The random seed.
    Changing this value gives a different “random” order when *Randomize* is checked.
    This order is always the same for a given seed/mesh set.
user: Give a detailed overview of Tips: syntax, arguments, return values, common patterns.

assistant: # Tips

As with all physics-enabled objects, pay close attention to the *Animated* checkbox
in the *Rigid Body* panel of the *Physics* tab in the Properties.
A common mistake is to use keyframe animation on a *Passive* physics
object without checking the *Animated* box. The object will move,
but the physics engine will behave as if the *Passive* is still in its starting place, leading to disappointment.
user: How do I use Mball Operators in Blender? Include parameters, examples, warnings and best practices.

assistant: # Mball Operators

bpy.ops.mball.delete_metaelems(*\**, *confirm=True*)
:   Delete selected metaball element(s)

    Parameters:
    :   **confirm** (*boolean**,* *(**optional**)*) – Confirm, Prompt for confirmation

bpy.ops.mball.duplicate_metaelems()
:   Duplicate selected metaball element(s)

bpy.ops.mball.duplicate_move(*\**, *MBALL_OT_duplicate_metaelems=None*, *TRANSFORM_OT_translate=None*)
:   Make copies of the selected metaball elements and move them

    Parameters:
    :   - **MBALL_OT_duplicate_metaelems** (`MBALL_OT_duplicate_metaelems`, (optional)) – Duplicate Metaball Elements, Duplicate selected metaball element(s)
        - **TRANSFORM_OT_translate** (`TRANSFORM_OT_translate`, (optional)) – Move, Move selected items

bpy.ops.mball.hide_metaelems(*\**, *unselected=False*)
:   Hide (un)selected metaball element(s)

    Parameters:
    :   **unselected** (*boolean**,* *(**optional**)*) – Unselected, Hide unselected rather than selected

bpy.ops.mball.reveal_metaelems(*\**, *select=True*)
:   Reveal all hidden metaball elements

    Parameters:
    :   **select** (*boolean**,* *(**optional**)*) – Select

bpy.ops.mball.select_all(*\**, *action='TOGGLE'*)
:   Change selection of all metaball elements

    Parameters:
    :   **action** (enum in [`'TOGGLE'`, `'SELECT'`, `'DESELECT'`, `'INVERT'`], (optional)) –

        Action, Selection action to execute

        - `TOGGLE`
          Toggle – Toggle selection for all elements.
        - `SELECT`
          Select – Select all elements.
        - `DESELECT`
          Deselect – Deselect all elements.
        - `INVERT`
          Invert – Invert selection of all elements.

bpy.ops.mball.select_random_metaelems(*\**, *ratio=0.5*, *seed=0*, *action='SELECT'*)
:   Randomly select metaball elements

    Parameters:
    :   - **ratio** (*float in* *[**0**,* *1**]**,* *(**optional**)*) – Ratio, Portion of items to select randomly
        - **seed** (*int in* *[**0**,* *inf**]**,* *(**optional**)*) – Random Seed, Seed for the random number generator
        - **action** (enum in [`'SELECT'`, `'DESELECT'`], (optional)) –

          Action, Selection action to execute

          - `SELECT`
            Select – Select all elements.
          - `DESELECT`
            Deselect – Deselect all elements.

bpy.ops.mball.select_similar(*\**, *type='TYPE'*, *threshold=0.1*)
:   Select similar metaballs by property types

    Parameters:
    :   - **type** (enum in [`'TYPE'`, `'RADIUS'`, `'STIFFNESS'`, `'ROTATION'`], (optional)) – Type
        - **threshold** (*float in* *[**0**,* *inf**]**,* *(**optional**)*) – Threshold
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: This shader is an implementation of the papers by Chiang et al. [[CBTB16]](#cbtb16) and Huang et al. [[HHH22]](#hhh22).

[CBTB16]
([1](#id1),[2](#id3),[3](#id4))

Chiang, M. J. , Bitterli, B. , Tappan, C. and Burley, B. (2016),
A Practical and Controllable Hair and Fur Model for Production Path Tracing. Computer Graphics Forum, 35: 275-283.
[doi:10.1111/cgf.12830](https://doi.org/10.1111/cgf.12830)

[[EFHLA11](#id2)]

d’Eon, E. , Francois, G. , Hill, M. , Letteri, J. and Aubry, J. (2011),
An Energy‐Conserving Hair Reflectance Model. Computer Graphics Forum, 30: 1181-1187.
[doi:10.1111/j.1467-8659.2011.01976.x](https://doi.org/10.1111/j.1467-8659.2011.01976.x)

[[HHH22](#id5)]

Huang W., Hullin M.B. Hanika J. (2022),
A Microfacet-based Hair Scattering Model. Computer Graphics Forum, 41: 79-91.
[doi:10.1111/cgf.14588](https://doi.org/10.1111/cgf.14588)
user: Explain Meta Strips in complete detail according to the official Blender documentation.

assistant: # Meta Strips

A Meta Strip is a strip which contain multiple strips treated as if it was one strip.
It allows you to reduce the vertical space used in the Sequencer.
You can edit it the same way as any other strips.

It is organization tool. For example, if you are using a lot of strips with
complicated arrangement, you can group them together using Meta strips.

Make Meta Strip `Ctrl`-`G`
:   To create a Meta strip, select all the strips you want to group, and `Ctrl`-`G` to group them.
    The Meta strips will span from the beginning of the first strip to the end of the last one,
    and condenses all channels into a single strip.

UnMeta Strip `Ctrl`-`Alt`-`G`
:   Separating (ungrouping) the Meta strip restores the strips to their relative positions and channels.
    This can be used if you choose to delete a Meta strip and want to keep the strips inside.

[image reference removed]

Example of Meta strips.

You can edit the content inside a Meta strip by pressing `Tab`.
It will expand the strip to the whole view and hide any other strips.
To exit the Meta strip press `Tab` again.
Meta strips can also be nested, which make editing them a little confusing.
To exit out one level of Meta Strip make sure you do not have a Meta strips selected when you press `Tab`.

One convenient use for Meta strips is when you want to apply the same effect to multiple strips.
For example: if you have a video that was recorded in different files and want to add an effect strip.
It is much more convenient to apply a single set of effects
to one Meta strip than applying it to each individual strip.
user: Provide the full official documentation entry for Separate Cylindrical Node, preserving all code examples.

assistant: # Separate Cylindrical Node

[image reference removed]

The *Separate Cylindrical* node converts a vector from Cartesian coordinates (X, Y, Z)
into cylindrical coordinates (R, Φ, Z) and outputs each component separately. It is the inverse of the
[Combine Cylindrical](../../../../modeling/geometry_nodes/utilities/vector/combine_cylindrical.xhtml) node.

This node is useful for analyzing geometry or generating procedural effects that depend on
radial distance, angular position, or height – for example, creating spiral deformations,
cylindrical gradients, or radial masks.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Geometry
:   The output geometry containing the generated hair curves.

Curves
:   A separate output of the generated curve data for further processing or inspection.

Surface Normal
:   The surface normal direction at each curve’s attachment point.
user: How do I use Advanced Gridlines Only in Blender? Include parameters, examples, warnings and best practices.

assistant: Advanced coloring options for gridlines.

Color Gridlines
:   Flags:
    :   Color gridlines with flags.

    Highlight Range:
    :   Grid Display Only
        Highlight the cells with values of the displayed grid within the range.
        Values between the *Lower Bound* and *Upper Bound* (inclusive) are considered to be within the range.

        Lower Bound
        :   Lower bound of the highlighting range.

        Upper Bound
        :   Upper bound of the highlighting range.

        Color
        :   Color used to highlight the cells.

        Cell Type
        :   Choose to highlight only a particular type of cells.
user: Give a detailed overview of Limitations: syntax, arguments, return values, common patterns.

assistant: Some OSL features are not available when using the OptiX backend. Examples include:

- Memory usage reductions offered by features like on-demand texture loading and
  :   mip-mapping are not available.
- Texture lookups require OSL to be able to determine a constant image file path for each
  :   texture call.
- Some noise functions are not available. Examples include *Cell*, *Simplex*, and *Gabor*.
- The [trace](#render-shader-nodes-osl-trace) function is not functional.
  As a result of this, the [Ambient Occlusion](../../shader_nodes/input/ao.html#bpy-types-shadernodeambientocclusion)
  and [Bevel](../../shader_nodes/input/bevel.html#bpy-types-shadernodebevel) nodes do not work.
user: Provide the full official documentation entry for Bisect, preserving all code examples.

assistant: # Bisect

The Bisect tool is a quick way to cut a mesh in two along a custom plane.

Use `LMB` click and drag to draw cut line.
Once the cut is done the [Adjust Last Operation](../../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel gives a few options:

Plane Point, Plane Normal
:   The plane can be numerically adjusted for precise values.

Fill
:   Cuts can optionally fill in the holes created,
    with materials, UV maps, and Color Attributes based on the surrounding geometry.

Clear Inner, Clear Outer
:   Cuts may remove geometry on one side.

Axis Threshold
:   Cut along the straight plane or along the existing geometry below the distance from the plane.
user: Explain Set Handle Type in complete detail according to the official Blender documentation.

assistant: Sets the handle type for the points on the Bézier curve that are in the selection.

Type
:   The handle type to switch to.

    Auto:
    :   This handle has a completely automatic length and direction
        which is set by Blender to ensure the smoothest result.
        These handles convert to *Align* handles when moved.

    Vector:
    :   Both parts of a handle always point to the previous handle or the next handle which allows
        you to create curves or sections thereof made of straight lines or with sharp corners.
        Vector handles convert to *Free* handles when moved.

    Align:
    :   These handles always lie in a straight line,
        and give a continuous curve without sharp angles.

    Free:
    :   The handles are independent of each other.

    Toggle Free/Align:
    :   Replaces Free handles with Align, and all Align with Free handles.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Curve
:   Standard geometry input.

Selection
:   Whether to change the cyclic setting for each spline. *True* means the
    setting will be changed, *false* means it will stay the same.

Cyclic
:   Whether to connect the first and last control points of each spline.
user: Provide the full official documentation entry for Boolean Modifier, preserving all code examples.

assistant: # Boolean Modifier

The *Boolean* modifier combines multiple meshes using a Boolean operation.

[image reference removed]

Applying the modifier to a sphere and creating the Intersection, Union, and Difference
with a cube. The cube is hidden for a better view.
user: Show practical ways to work with ObjectBase(bpy_struct) in a Blender add-on or script – include code.

assistant: # ObjectBase(bpy_struct)

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

*class* bpy.types.ObjectBase(*bpy_struct*)
:   An object instance in a View Layer (currently never exposed in Python API)

    hide_viewport
    :   Temporarily hide in viewport

        Type:
        :   boolean, default False

    object
    :   Object this base links to

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

    select
    :   Object base selection state

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Update Example in a Blender add-on or script – include code.

assistant: It can be useful to perform an action when a property is changed and can be
used to update other properties or synchronize with external data.

All properties define update functions except for CollectionProperty.

```
import bpy

def update_func(self, context):
    print("my test function", self)

bpy.types.Scene.testprop = bpy.props.FloatProperty(update=update_func)

bpy.context.scene.testprop = 11.0

# >>> my test function <bpy_struct, Scene("Scene")>
```
user: Give a detailed overview of Text Editing in Preview: syntax, arguments, return values, common patterns.

assistant: Text strips can be edited directly in the **Preview** window, providing a more intuitive workflow.

- **Enable Editing**: Press `Tab` to enter edit mode. A boundary box and cursor will appear.
- **Disable Editing**: Press `Tab` again to exit edit mode.

### Editing

Copy Text `Ctrl`-`C`
:   Copy the selected text.

Paste Text `Ctrl`-`V`
:   Uses the system clipboard, allowing text from external applications to be pasted.

Cut Text `Ctrl`-`X`
:   Cut the selected text.

Delete Character `Backspace`
:   Delete the character before the cursor.

Insert Line Break `Return`
:   Insert a new line.

Select All `Ctrl`-`A`
:   Select all the text.

Deselect All `Esc`
:   Deselect the text.

### Navigation

- `Left` – Move the cursor one character left.
- `Right` – Move the cursor one character right.
- `Up` – Move the cursor one line up\*\*.
- `Down` – Move the cursor one line down\*\*.
- `Home` – Move the cursor to the beginning of the current line.
- `End` – Move the cursor to the end of the current line.
- `Ctrl`-`Left` – Move the cursor one word left.
- `Ctrl`-`Right` – Move the cursor one word right.
- `PageUp` – Move the cursor to the start of the text.
- `PageDown` – Move the cursor to the end of the text.

### Text Selection

Holding `Shift` while pressing a navigation key enables text selection.

- `Shift`-`Left` – Select the previous character.
- `Shift`-`Right` – Select the next character.
- `Shift`-`Up` – Select the previous line.
- `Shift`-`Down` – Select the next line.
- `Shift`-`Home` – Select from the cursor to the beginning of the line.
- `Shift`-`End` – Select from the cursor to the end of the line.
- `Shift`-`Ctrl`-`Left` – Select the previous word.
- `Shift`-`Ctrl`-`Right` – Select the next word.
- `Shift`-`PageUp` – Select from the cursor to the start of the text.
- `Shift`-`PageDown` – Select from the cursor to the end of the text.
user: Provide the full official documentation entry for Instance on Points Node, preserving all code examples.

assistant: # Instance on Points Node

[image reference removed]

The *Instance on Points* node adds a reference to a geometry to each of the points present
in the input geometry. Instances are a fast way to add the same geometry to a scene many times
without duplicating the underlying data. The node works on any geometry type
with a *Point* domain, including meshes, point clouds, and curve control points.

Any attributes on the points from the *Geometry* input will be available on the instance
domain of the generated instances.
user: Provide the full official documentation entry for Inherited Properties, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") | - [`LineStyleAlphaModifier.name`](bpy.types.LineStyleAlphaModifier.html#bpy.types.LineStyleAlphaModifier.name "bpy.types.LineStyleAlphaModifier.name") |
user: Provide the full official documentation entry for Requirements, preserving all code examples.

assistant: - Wheels must be bundled unmodified from [Python’s package index](https://pypi.org).
- Wheels must include their dependencies.
- Wheels filenames must match Python’s binary distribution specification:
  [see docs](https://packaging.python.org/en/latest/specifications/binary-distribution-format/#file-name-convention).
  *Wheels downloaded from Python’s package index will follow this convention.*
- Use forward slashes as path separators when listing them on the
  [manifest](getting_started.xhtml#extensions-manifest).
user: Describe Limit Rotation Constraint from the Blender manual or Python API, including usage steps and snippets.

assistant: # Limit Rotation Constraint

The *Limit Rotation* constraint limits the Euler rotation angle for each axis
to a certain range.

Angles outside a range are clamped to whichever boundary is closer on a circle.
For example, if an axis is limited to the range 0°-90° and the original rotation
is 340°, the constraint changes this to 0°, not 90°.

This constraint doesn’t work for bones that are affected by [Inverse Kinematics](../../armatures/posing/bone_constraints/inverse_kinematics/introduction.html).
Please use the *Limit* settings in the bone’s [IK panel](../../armatures/posing/bone_constraints/inverse_kinematics/introduction.html#bpy-types-posebone-ik)
instead.
user: What is Light Probe Plane and how is it used in Blender Python scripting?

assistant: # Light Probe Plane

A light probe plane records the light incoming from a single direction for all visible points on a plane.
The specular reflection direction is the only one currently available.

This type of light probe is suited to smooth planar surfaces.

Each visible planar light probe increases the render time as the scene needs to be rendered for
each of them.

Light probe planes only work when the ray tracing method is set to `Screen-Trace`.
When enabled, they accelerate the tracing process and complete the missing data from the screen space ray tracing.
user: Provide the full official documentation entry for Channel Key Node, preserving all code examples.

assistant: # Channel Key Node

[image reference removed]

The *Channel Key* node determines background objects from foreground objects by
the difference in the selected channel’s levels.

For example in the YUV [Color Model](../../../glossary/index.xhtml#term-Color-Model),
this node is useful when compositing stock footage of explosions (very bright)
which are normally shot against a solid, dark background.
user: Provide the full official documentation entry for Mouse Clicks, preserving all code examples.

assistant: If at least one bone is selected, `Ctrl`-`RMB`-clicking adds a new bone.

About the new bone’s tip:

After you `Ctrl`-`RMB`-clicked it becomes the active element in the armature,
it appears to be right where you clicked, but (as in mesh editing)
it will be on the plane parallel to the view and passing through the 3D cursor.

The position of the root and the parenting of the new bone depends on the active element:

[image reference removed]

`Ctrl`-clicking when the active element is a bone.

If the active element is a *bone*:

- The new bone’s root is placed on the active bone’s tip.
- The new bone is parented and connected to the active bone
  (check the Outliner in Fig. [Ctrl-clicking when the active element is a tip.](#fig-rig-bone-active-tip)).

[image reference removed]

`Ctrl`-clicking when the active element is a tip.

If the active element is a *tip*:

- The new bone’s root is placed on the active tip.
- The new bone is parented and connected to the bone owning the active tip
  (check the Outliner in Fig. [Ctrl-clicking when the active element is a tip.](#fig-rig-bone-active-tip)).

[image reference removed]

`Ctrl`-clicking when the active element is a disconnected root.

If the active element is a *disconnected root*:

- The new bone’s root is placed on the active root.
- The new bone is **not** parented to the bone owning the active root
  (check the Outliner in Fig. [Ctrl-clicking when the active element is a disconnected root.](#fig-rig-bone-disconnected-tip)).

And hence the new bone will **not** be connected to any bone.

[image reference removed]

`Ctrl`-clicking when the active element is a connected root.

If the active element is a *connected root*:

- The new bone’s root is placed on the active root.
- The new bone **is** parented and connected to the parent of the bone owning the active root
  (check the Outliner in Fig. [Ctrl-clicking when the active element is a connected root.](#fig-rig-bone-connected-root)).

This should be obvious because if the active element is a connected root
then the active element will be also the tip of the parent bone,
so it is the same as the second case.

As the tip of the new bone becomes the active element,
you can repeat these `Ctrl`-`RMB` clicks several times,
to consecutively add several bones to the end of the same chain.