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

assistant: Selection Mask
:   Vertex Paint Mode in Grease Pencil allows you to select points or strokes to restrict the effect
    of the painting tools to only a certain areas of your drawing.

    You can use the selection tools in the Toolbar for a quick selections.

    You can restrict painting only on the selected points or strokes with the Selection mode toggle.
    The three modes can be toggled with `1`, `2`, or `3` respectively.

Multiframe
:   Sometimes you may need to modify several frames at the same time with the painting tools.

    You can activate multiframe editing with the Multiframe button next to the modes selector (faded lines icon).
    See [Multiframe](../../multiframe.xhtml) for more information.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: The node can contain an arbitrary number of input sockets.
Each socket can be given a custom name and type. Supported types include (but not limited to):

- Geometry
- Objects
- Values (e.g. float, integer, boolean, vector, color)
- Fields
- Nested Bundles
user: What is Hook Modifier and how is it used in Blender Python scripting?

assistant: # Hook Modifier

The *Hook* modifier is used to deform a mesh, curve or lattice using another object
(usually an empty or a bone but it can be any object).
As an object specified as hook moves, it pulls vertices or control points from the geometry with it.
You can think of it as animated
[Proportional Editing](../../../editors/3dview/controls/proportional_editing.html).

While hooks do not give you the fine control over vertices movement that shape keys do,
they have the advantage that you can select vertices directly for manipulation.

To assign selected vertices (in Edit Mode) you can use the *Assign* button on the modifier panel
or use the [Add Hook](../../meshes/editing/vertex/hooks.html#bpy-ops-object-hook-add-selob) menu.
user: How do I use VIEW3D_AST_brush_texture_paint(AssetShelf) in Blender? Include parameters, examples, warnings and best practices.

assistant: # VIEW3D_AST_brush_texture_paint(AssetShelf)

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

*class* bpy.types.VIEW3D_AST_brush_texture_paint(*AssetShelf*)
:   *classmethod* brush_type_poll(*context*, *asset*)

    *static* draw_popup_selector(*layout*, *context*, *brush*, *show_name=True*)

    *static* get_shelf_name_from_context(*context*)

    *classmethod* has_tool_with_brush_type(*context*, *brush_type*)

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

assistant: The object to be painted on must first be [unwrapped](../../modeling/meshes/uv/unwrapping/introduction.xhtml).
UVs can be added traditionally, with standard [Unwrapping Tools](../../modeling/meshes/editing/uv.xhtml),
or by adding [Simple UVs](tool_settings/texture_slots.xhtml#bpy-ops-paint-add-simple-uvs) in Texture Paint mode.

Once you have unwrapped your model to a UV map, you can begin the texturing process.
To use texture paint you may do any of the following:

- Activate the Texture Paint workspace. Here the 3D Viewport has the Texture Paint Mode enabled
  and the Image Editor is already switched to Paint mode.
- In the 3D Viewport, select Texture Paint Mode from the mode selector in the header,
  and you can paint directly onto the mesh.
- In the Image Editor, switch the mode to Paint (shown in the image to the right).

[image reference removed]

Enabling Paint mode.

Once you enable Texture Painting, your mouse becomes a brush.
As soon as you enable Texture Painting or switch to Texture Paint Mode,
different tools become available in the Toolbar.

In the Image Editor, you paint on a flat canvas that is wrapped around the mesh using UV coordinates.
Any changes made in the Image Editor show up immediately in the 3D Viewport, and vice versa.

To work with the UV layout (for example, to move coordinates) you must use the [UV Editor](../../editors/uv/index.xhtml).

A full complement of brushes and colors can be selected from the Sidebar region in the Image Editor.
Brush changes made in either panel are immediately reflected in the other panel.
However, the modified texture will **not** be saved automatically;
you must explicitly do so with [Save Image](../../editors/image/editing.xhtml#bpy-ops-image-save).
user: Give a detailed overview of GeometryNodeGizmoDial(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeGizmoDial(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.GeometryNodeGizmoDial(*GeometryNode*)
:   Show a dial gizmo in the viewport for a value

    color_id
    :   Type:
        :   enum in [Geometry Nodes Gizmo Color Items](bpy_types_enum_items/geometry_nodes_gizmo_color_items.html#rna-enum-geometry-nodes-gizmo-color-items), default `'PRIMARY'`

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

assistant: # UnknownType(bpy_struct)

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

*class* bpy.types.UnknownType(*bpy_struct*)
:   Stub RNA type used for pointers to unknown or internal data

    *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 Options in complete detail according to the official Blender documentation.

assistant: ### Collapse

[[image reference removed]](../../../_images/modeling_modifiers_generate_decimate_panel-collapse.png)

The Decimate modifier in Collapse mode.

Merges vertices together progressively, taking the shape of the mesh into account.

Ratio
:   The ratio of faces to keep after decimation.

    - On 1.0: the mesh is unchanged.
    - On 0.5: edges have been collapsed such that half the number of faces remain (see note below).
    - On 0.0: all faces have been removed.

Symmetry
:   Maintains symmetry on a single axis.

Triangulate
:   Keeps any resulting triangulated geometry from the decimation process.

Vertex Group
:   A vertex group that controls what parts of the mesh are decimated.

Factor
:   The amount of influence the *Vertex Group* has on the decimation.

### Un-Subdivide

[[image reference removed]](../../../_images/modeling_modifiers_generate_decimate_panel-un-subdivide.png)

The Decimate modifier in Un-Subdivide mode.

It can be thought of as the reverse of subdivide.
It attempts to remove edges that were the result of a subdivide operation.
It is intended for meshes with a mainly grid-based topology (without giving uneven geometry).
If additional editing has been done after the subdivide operation, the results may be unexpected.

Iterations
:   The number of times to perform the un-subdivide operation.
    Two iterations is the same as one subdivide operation, so you will usually want to use even numbers.

### Planar

[[image reference removed]](../../../_images/modeling_modifiers_generate_decimate_panel-planar.png)

The Decimate modifier in Planar mode.

It reduces details on forms comprised of mainly flat surfaces.

Angle Limit
:   Dissolve geometry which form angles (between surfaces) higher than this setting.

Delimit
:   Prevent dissolving geometry in certain places.

    Normal
    :   Does not dissolve edges on the borders of areas where the face normals are reversed.

    Material
    :   Does not dissolve edges on the borders of where different materials are assigned.

    Seam
    :   Does not dissolve edges marked as seams.

    Sharp
    :   Does not dissolve edges marked as sharp.

    UVs
    :   Does not dissolve edges that are part of a UV map.

All Boundaries
:   When enabled, all vertices along the boundaries of faces are dissolved.
    This can give better results when using a high *Angle Limit*.
user: Explain Monkey in complete detail according to the official Blender documentation.

assistant: Adds a stylized monkey head mesh named “Suzanne”.
Suzanne is a gift from old NaN to the community and
remains in Blender as a playful “Easter egg” and is widely recognized as Blender’s mascot.

This primitive is commonly used for testing materials, lighting setups, and modifiers such as
[Subdivision Surface](../../glossary/index.xhtml#term-Subdivision-Surface).

It serves a similar purpose to well-known test models like the
[Utah Teapot](https://en.wikipedia.org/wiki/Utah_teapot) or the
[Stanford Bunny](https://en.wikipedia.org/wiki/Stanford_Bunny).

Size
:   Controls the overall scale of the mesh.
user: How do I use Bpy.Types.Stripstoplevel in Blender? Include parameters, examples, warnings and best practices.

assistant: nf ] ) – The start frame for the new strip length ( int in [ -inf , inf ] , ( optional ) ) – Length of the strip in frames, or the length of each strip if multiple are added input1 ( Strip , (optional)) – First input strip for effect input2 ( Strip , (optional)) – Second input strip for effect Returns : New Strip Return type : Strip remove ( sequence ) ¶ Remove a Strip Parameters : sequence ( Strip , (never None)) – Strip to remove classmethod bl_rna_get_subclass ( id , default = None , / ) ¶ Parameters : id ( str ) – The RNA type identifier. Returns : The RNA type or default when not found. Return type : bpy.types.Struct 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 Inherited Properties ¶ bpy_struct.id_data Inherited Functions ¶ bpy_struct.as_pointer bpy_struct.driver_add bpy_struct.driver_remove bpy_struct.get bpy_struct.id_properties_clear bpy_struct.id_properties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values References ¶ SequenceEditor.strips Next Struct(bpy_struct) Previous StripsMeta(bpy_struct) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page StripsTopLevel(bpy_struct) StripsTopLevel StripsTopLevel.new_clip() StripsTopLevel.new_mask() StripsTopLevel.new_scene() StripsTopLevel.new_image() StripsTopLevel.new_movie() StripsTopLevel.new_sound() StripsTopLevel.new_meta() StripsTopLevel.new_effect() StripsTopLevel.remove() StripsTopLevel.bl_rna_get_subclass() StripsTopLevel.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Describe bpy_extras submodule (bpy_extras.id_map_utils) from the Blender manual or Python API, including usage steps and snippets.

assistant: # bpy_extras submodule (bpy_extras.id_map_utils)

bpy_extras.id_map_utils.get_id_reference_map()
:   Return a dictionary of direct data-block references for every data-block in the blend file.

bpy_extras.id_map_utils.get_all_referenced_ids(*id*, *ref_map*)
:   Return a set of IDs directly or indirectly referenced by id.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Image
:   Standard color input.

Type
:   Undistort:
    :   Used to undistort the image received, and is usually used for the raw distorted movie clip.

    Distort:
    :   Used to distort the image received, and is usually used for rendered images.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

assistant: Space
:   The input RGB color can be in one of three spaces: Tangent, Object and World space.
    Tangent space normal maps are the most common, as they support object transformation and mesh deformations.
    Object space normal maps keep sticking to the surface under object transformations,
    while World normal maps do not.

UV Map
:   Name of the UV map to derive normal mapping tangents from. When chained with an Image Texture node,
    this UV map should be the same as the UV map used to map the texture.
user: How do I use ThemeTextEditor(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ThemeTextEditor(bpy_struct)

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

*class* bpy.types.ThemeTextEditor(*bpy_struct*)
:   Theme settings for the Text Editor

    cursor
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    line_numbers
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    line_numbers_background
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    selected_text
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    space
    :   Settings for space

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

    syntax_builtin
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    syntax_comment
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    syntax_numbers
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    syntax_preprocessor
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    syntax_reserved
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    syntax_special
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    syntax_string
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    syntax_symbols
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Why does an operator’s poll fail? and how is it used in Blender Python scripting?

assistant: When calling an operator it gives an error like this:

```
>>> bpy.ops.action.clean(threshold=0.001)
RuntimeError: Operator bpy.ops.action.clean.poll() failed, context is incorrect
```

Which raises the question as to what the correct context might be?

Typically operators check for the active area type, a selection or active object they can operate on,
but some operators are more strict when they run.
In most cases you can figure out what context an operator needs
by examining how it’s used in Blender and thinking about what it does.

If you’re still stuck, unfortunately, the only way to eventually know what is causing the error is
to read the source code for the poll function and see what it is checking.
For Python operators it’s not so hard to find the source
since it’s included with Blender and the source file and line is included in the operator reference docs.
Downloading and searching the C code isn’t so simple,
especially if you’re not familiar with the C language but by searching the operator name or description
you should be able to find the poll function with no knowledge of C.
user: Give a detailed overview of MaskSpline(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # MaskSpline(bpy_struct)

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

*class* bpy.types.MaskSpline(*bpy_struct*)
:   Single spline used for defining mask shape

    offset_mode
    :   The method used for calculating the feather offset

        - `EVEN`
          Even – Calculate even feather offset.
        - `SMOOTH`
          Smooth – Calculate feather offset as a second curve.

        Type:
        :   enum in [`'EVEN'`, `'SMOOTH'`], default `'EVEN'`

    points
    :   Collection of points

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

    use_cyclic
    :   Make this spline a closed loop

        Type:
        :   boolean, default False

    use_fill
    :   Make this spline filled

        Type:
        :   boolean, default False

    use_self_intersection_check
    :   Prevent feather from self-intersections

        Type:
        :   boolean, default False

    weight_interpolation
    :   The type of weight interpolation for spline

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

    *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 NodeTreeInterfaceSocketGeometry(NodeTreeInterfaceSocket) and how is it used in Blender Python scripting?

assistant: # NodeTreeInterfaceSocketGeometry(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.NodeTreeInterfaceSocketGeometry(*NodeTreeInterfaceSocket*)
:   Geometry socket of a node

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

assistant: Gizmo settings for [empties](../../../modeling/empties.xhtml).

Image
:   Show the gizmo to adjust the image size and position.

Force Field
:   Show the gizmo to adjust the [force field](../../../physics/forces/force_fields/introduction.xhtml).
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Guide Curves
:   Base curves that new curves are interpolated between.

Guide Up
:   Optional up vector that is typically a surface normal. Supplying an up vector will improve
    the quality of the interpolation, making it aware of the surface shape which it otherwise
    wouldn’t have a way to know about.

Guide Group ID
:   Splits guides into separate groups. New curves interpolate existing curves from a single group.
    This input can be useful for generating hair parts by stopping curves in different sections
    (with different group IDs) from affecting each other.

Points
:   The positions of the first root control points of the newly generated interpolated curves.

Points Up
:   Optional up vector that is typically a surface normal.

Point Group ID
:   The curve group to interpolate in.

Max Neighbors
:   Maximum amount of close guide curves that are taken into account for interpolation.
user: Show practical ways to work with Select Mirror in a Blender add-on or script – include code.

assistant: # Select Mirror

Select Mirror flips a selection to the opposite side of the mesh.

Axis
:   Choose on which axis the selection will occur. The axis is based on the meshes origin.
    Therefore, if the origin is not centered within the mesh, the selection will have varying results.

Extend
:   The new selection will include the mirrored selection as well as the original.

[image reference removed]

(From left to right) initial selection, after Select Mirror on the X axis, with Extend.
user: Give a detailed overview of Python Options: syntax, arguments, return values, common patterns.

assistant: `-y`, `--enable-autoexec`
:   Enable automatic Python script execution.

`-Y`, `--disable-autoexec`
:   Disable automatic Python script execution (Python-drivers & startup scripts), (default).

`-P`, `--python` `<filepath>`
:   Run the given Python script file.

`--python-text` `<name>`
:   Run the given Python script text block.

`--python-expr` `<expression>`
:   Run the given expression as a Python script.

`--python-console`
:   Run Blender with an interactive console.

`--python-exit-code` `<code>`
:   Set the exit-code in [0..255] to exit if a Python exception is raised
    (only for scripts executed from the command line), zero disables.

`--python-use-system-env`
:   Allow Python to use system environment variables such as `PYTHONPATH` and the user site-packages directory.

`--addons` `<addon(s)>`
:   Comma separated list (no spaces) of add-ons to enable in addition to any default add-ons.
user: Describe Transform from the Blender manual or Python API, including usage steps and snippets.

assistant: Move `G`
:   Move the selected strips in time or to a different track.

Extend `E`
:   Lets you quickly move the selected strips that are on a certain side of the Playhead.
    This is handy if you need to, say, move all the strips after a certain time point to
    the right to make space for new ones.

    To use this operator, first select some or all strips and place your mouse cursor to
    the left or right of the Playhead. Then, press `E`, move the mouse to move (only)
    the strips on that side of the Playhead, and press `LMB` to confirm
    (or `RMB` to cancel).

    If a strip straddles the Playhead, only its starting/ending point will be moved
    (again depending on the position of the mouse cursor).

Scale `S`
:   Scales the selected strips, using the Playhead as the pivot point.

### Swap

Swap the order of the selected strips in their track.

### Move Up

Move selected strips up a track if there is room.

### Move Down

Move selected strips down a track if there is room.
user: Give a detailed overview of Brush Tool: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The *Brush* tool.

Painting or sculpting with brushes requires the brush tool to be active. Activating a brush from an
asset shelf or brush selector also activates the brush tool for convenience.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

2D Stabilization panel.

Anchor Frame
:   Reference point to anchor stabilization:
    other frames will be adjusted relative to this frame’s position, orientation and scale.
    You might want to select a frame number where your main subject is featured in an optimal way.

Stabilization Type
:   Rotation
    :   In addition to location, stabilizes detected rotation around the *rotation pivot point*,
        which is the weighted average of all location tracking points.

    Scale
    :   Compensates any scale changes relative to center of rotation.

Tracks for Stabilization
:   Location
    :   List of tracks to be used to compensate for camera jumps, or location movement.

    Rotation/Scale
    :   List of tracks to be used to compensate for camera tilts and scale changes.

Autoscale
:   Finds smallest scale factor which, when applied to the footage,
    would eliminate all empty black borders near the image boundaries.

    Max
    :   Limits the amount of automatic scaling.

Expected Position X/Y
:   Known relative offset of original shot, will be subtracted, e.g. for panning shots.

Expected Rotation
:   Rotation present on original shot, will be compensated, e.g. for deliberate tilting.

Expected Zoom
:   Explicitly scale resulting frame to compensate zoom of original shot.

Influence
:   The amount of transformation applied to the footage can be controlled.
    In some cases it is not necessary to fully compensate camera jumps.
    The amount of stabilization applied to the footage can be controlled.
    In some cases you may not want to fully compensate some of the camera’s jumps.
    Please note that these “\* *Influence*” parameters do control only the *compensation movements*
    calculated by the stabilizer, not the deliberate movements added through the “*Expected* \*”-parameters.

Interpolate
:   The stabilizer calculates compensation movements with sub-pixel accuracy.
    Consequently, a resulting image pixel needs to be derived from several adjacent source footage pixels.
    Unfortunately, any interpolation causes some minor degree of softening and loss of image quality.

    Nearest
    :   No interpolation, uses nearest neighboring pixel.
        This setting basically retains the original image’s sharpness.
        The downside is we also retain residual movement below the size of one pixel,
        and compensation movements are done in 1 pixel steps, which might be noticeable as irregular jumps.

    Bilinear
    :   Simple linear interpolation between adjacent pixels.

    Bicubic
    :   Highest quality interpolation, most expensive to calculate.
user: Show practical ways to work with References in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| - [`BlendData.sounds`](bpy.types.BlendData.html#bpy.types.BlendData.sounds "bpy.types.BlendData.sounds") - [`BlendDataSounds.load`](bpy.types.BlendDataSounds.html#bpy.types.BlendDataSounds.load "bpy.types.BlendDataSounds.load") - [`BlendDataSounds.remove`](bpy.types.BlendDataSounds.html#bpy.types.BlendDataSounds.remove "bpy.types.BlendDataSounds.remove") | - [`SoundStrip.sound`](bpy.types.SoundStrip.html#bpy.types.SoundStrip.sound "bpy.types.SoundStrip.sound") - [`Speaker.sound`](bpy.types.Speaker.html#bpy.types.Speaker.sound "bpy.types.Speaker.sound") |
user: Provide the full official documentation entry for Importing Alembic Files, preserving all code examples.

assistant: When importing an Alembic file, [Mesh Sequence Cache modifiers](../../modeling/modifiers/modify/mesh_sequence_cache.html)
are automatically added to time-varying meshes. For time-varying object transforms
(so animation of rotation, location, or scale)
the [Transform Cache Constraint](../../animation/constraints/transform/transform_cache.html#bpy-types-transformcacheconstraint) is used.

### General

Scale
:   Value by which to enlarge or shrink the objects with respect to the world’s origin

### Options

Relative Path
:   Select the file relative to the blend-file.

Set Frame Range
:   If checked, update scene’s start and end frame to match those of the Alembic archive.

Is Sequence
:   Set to true if the cache is split into separate files.

Validate Meshes
:   Check the imported mesh for corrupt data and fix it if necessary.
    When disabled, erroneous data may cause crashes displaying or editing the meshes.
    This option will make the importing slower but is recommended, as data errors are not always obvious.

Always Add Cache Reader
:   Add cache modifiers and constraints to imported objects even if they are
    not animated so that they can be updated when reloading the Alembic archive.
user: Show practical ways to work with Report on the Web in a Blender add-on or script – include code.

assistant: The process here is similar to reporting from within Blender, with the added step of specifying details about your
computer.

To initiate a bug report:

- Open the bug reporting template on [projects.blender.org](https://projects.blender.org/blender/blender/issues/new?template=.gitea/issue_template/bug.yaml).
- Give the bug a clear, easy-to-understand title - try to avoid long run-on sentences.
- Specify details about your computer and operating system in the **System Information** and **Blender Version**
  sections.
- Enter details about the steps to reproduce the bug. Bugs that are not consistently reproducible may be more
  difficult to track down, so provide any additional information that you can. Make sure to fill in the **Short
  description of error** and the **Exact steps for others to reproduce the error** sections.
- Attach any pictures if you feel they will help the developers understand the issue more clearly. Videos can also be
  attached, but please only do so if it is absolutely required to show the issue.
- If a crash occurs, attach a crash log as discussed below: [Attaching a Crash Log](#attaching-a-crash-log).
user: Describe CollisionModifier(Modifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CollisionModifier(Modifier)

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

*class* bpy.types.CollisionModifier(*Modifier*)
:   Collision modifier defining modifier stack position used for collision

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Image
:   Standard color input.

Factor
:   Controls the amount of influence the node exerts on the output image.

Type
:   The mathematical method to adjust the image’s colors.

    Lift/Gamma/Gain:
    :   Adjusts the colors and tonal range of an image by controlling the shadows, midtones, and highlights separately.

    Offset/Power/Slope (ASC-CDL):
    :   A standardized model for adjusting the colors and tonal range of an image.
        This allows the same values to be used across different application to yield the same result.
        See [Advanced](#advanced) for more details on the underlying implementation.

    White Point:
    :   Adjusts the color that should be considered white.
        The white point is specified as setting the inputs color temperature and then the desired output temperature.

Lift/Gamma/Gain

Lift
:   Adjusts the darkest areas of the image (the shadows).

Gamma
:   Primarily affects the midtones, the middle range of brightness in the image.

Gain
:   Controls the brightest parts of the image (the highlights).

Offset/Power/Slope (ASC-CDL)

Offset
:   Adjusts the darkest areas of the image (the shadows).

Basis
:   Additional offset, allows to specify a negative offset value.

Power
:   Primarily affects the midtones, the middle range of brightness in the image.

Slope
:   Controls the brightest parts of the image (the highlights).

### Input

Temperature
:   The blackbody temperature of the input’s primary illuminant. By default a D65 white point is used.

Tint
:   The amount of green/magenta shift of the input’s white point (the default of 10 matches daylight)

### Output

Temperature
:   The blackbody temperature of the output’s primary illuminant. By default a D65 white point is used.

Tint
:   The amount of green/magenta shift of the output’s white point (the default of 10 matches daylight)
user: Provide the full official documentation entry for Output, preserving all code examples.

assistant: Geometry
:   Standard geometry output.

Duplicate Index
:   An attribute field with a value for every output element describing which
    duplicate of the corresponding input. The value for every input element will
    start at 0 and increase to `Amount - 1`.
user: What is Aligning and how is it used in Blender Python scripting?

assistant: # Aligning

These options allow you to align and orient the view.

Align View to Active
:   Aligns the view to a certain local axis of the active object, bone, or (in Edit Mode)
    the normal of the active face. The view also becomes orthographic.

    To return to the regular (untilted) perspective view, you can first press `Numpad3`
    to align to the global X axis, then orbit with `MMB`.

Align Active Camera to View `Ctrl`-`Alt`-`Numpad0`
:   Moves and rotates the active camera so it matches the current viewpoint.

Align Active Camera to Selected
:   Moves the active camera (without changing its orientation) so that its view
    frames the selected objects.

Center Cursor and Frame All `Shift`-`C`
:   Moves the [3D Cursor](../3d_cursor.html) back to the world origin
    and changes the view so that you can see everything in your scene.

Center View to Cursor
:   Centers the view on the 3D Cursor.

View Lock to Active
:   Centers the view on the active object and makes it the point of interest. The view
    will continue orbiting around the object even if you pan to a different location.
    In addition, it will follow the object if it moves.

View Lock Clear
:   Returns the view to how it was before using *View Lock to Active*.
user: Explain Outputs in complete detail according to the official Blender documentation.

assistant: Points
:   Generated points. Named attributes are copied to the result mesh, along with the data in the other
    attribute field outputs.

Normal
:   The [Normal](../../../glossary/index.xhtml#term-Normal) of the triangle on which each point is scattered.

Rotation
:   An XYZ [Euler](../../../glossary/index.xhtml#term-Euler) rotation built from the normal attribute for convenience. Such a value can also be
    built from the normal with the [Euler to Rotation Node](../utilities/rotation/euler_to_rotation.xhtml).
    Keep in mind that the Z axis of the result rotation will be arbitrary, since the mesh normal used
    to create the rotation does not have enough information to set all three rotation axes.
user: Explain Notes in complete detail according to the official Blender documentation.

assistant: In some configurations of the node, especially for low values of *Randomness*,
rendering artifacts may occur. This happens due to the same reasons described
in the [Notes section](../../../render/shader_nodes/textures/white_noise.xhtml#shader-white-noise-notes) in the White Noise Texture page
and can be fixed in a similar manner as described there.
user: How do I use Keyframe Types in Blender? Include parameters, examples, warnings and best practices.

assistant: For visually distinguishing regular keyframes from different animation events or
states (extremes, breakdowns, or other in-betweens)
there is the possibility of applying different colors on them for visualization.

[image reference removed]

Left: not selected; Right: selected.

Keyframe (white / yellow diamond)
:   Normal keyframe.

Breakdown (small cyan diamond)
:   Breakdown state. e.g. for transitions between key poses.

Moving Hold (dark gray / orange diamond)
:   A keyframe that adds a small amount of motion around a holding pose.
    In the Dope Sheet it will also display a bar between them.

Extreme (big pink diamond)
:   An ‘extreme’ state, or some other purpose as needed.

Jitter (tiny green diamond)
:   A filler or baked keyframe for keying on ones, or some other purpose as needed.

Generated (dark diamond)
:   A key generated by some tool, for example [Copy Global Transform: Fix to
    Camera](../../editors/3dview/animation/copy_global_transform.html#bpy-types-toolsettings-anim-fix-to-cam). This keyframe type indicates
    to Blender and add-ons that it is safe to remove and re-generate them, so be
    careful when manually marking your hand-made animation with this type.
user: Provide the full official documentation entry for ScriptDirectory(bpy_struct), preserving all code examples.

assistant: # ScriptDirectory(bpy_struct)

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

*class* bpy.types.ScriptDirectory(*bpy_struct*)
:   directory
    :   Alternate script path, matching the default layout with sub-directories: startup, add-ons, modules, and presets (requires restart)

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

    name
    :   Identifier for the Python scripts directory

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Shrinkwrap Constraint

The *Shrinkwrap* constraint snaps an object or bone to the surface of a mesh. It’s similar
to the [Shrinkwrap Modifier](../../../modeling/modifiers/deform/shrinkwrap.xhtml), which snaps every vertex of a mesh to
the surface of another.

Like other constraints, the *Shrinkwrap* constraint ignores the geometry of its owner object
and purely works with its [origin](../../../scene_layout/object/origin.xhtml). This means that, if the
origin is at the object’s center, the object will clip into the target mesh instead of sitting
on its surface. This can be mitigated with the *Distance* setting.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Seconds
:   Current scene time in seconds.

Frames
:   Current scene frame.
    As an input in geometry nodes, this output may also output non-round numbers,
    in order to support higher quality [motion blur](../../../../render/eevee/render_settings/motion_blur.xhtml).
user: Provide the full official documentation entry for Linked Flat Faces, preserving all code examples.

assistant: Selects all connected faces with a similar angle.

Sharpness
:   Select connected faces with a reference angle less than the value specified.

[image reference removed]

Looking at the image above, when at least one face is selected (as seen on the left),
*Linked Flat Faces* will select all connecting faces that lie
on the same or similar plane (as shown in the middle image).
If the corners are smoothed, those faces are no longer lined up with the selected faces.
At this point, increasing the *Sharpness* value in the tool options could include the smoothed faces.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The Smooth modifier.

Axis
:   Enable/disable the modifier in the X, Y and/or Z axes directions.

Factor
:   Controls the smoothing amount.
    Higher values will increase the effect.

    Values outside expected range (above 1.0 or below 0.0) will distort the mesh.

Repeat
:   The number of smoothing iterations,
    equivalent to executing the *Smooth* tool multiple times.

Vertex Group
:   If set, restrict the effect to the only vertices in that vertex group.
    This allows for selective, real-time smoothing, by painting vertex weights.

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

        The setting reverses the weight values of the group.
user: Provide the full official documentation entry for Example, preserving all code examples.

assistant: |  |  |
| --- | --- |
| <../../../_images/render_eevee_render-settings_motion-blur_1step-nofx.png>   No motion blur. | <../../../_images/render_eevee_render-settings_motion-blur_1step-fx.png>   Only post-process blur. |
| <../../../_images/render_eevee_render-settings_motion-blur_4step-nofx.png>   4 time steps without post-process blur. | <../../../_images/render_eevee_render-settings_motion-blur_4step-fx.png>   4 time steps with post-process blur. |
| <../../../_images/render_eevee_render-settings_motion-blur_32step-nofx.png>   32 time steps without post-process blur. | <../../../_images/render_eevee_render-settings_motion-blur_32step-fx.png>   32 time steps with post-process blur. |
user: What is Color Tagging and how is it used in Blender Python scripting?

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

To assign a color to a collection,
use the [Set Color Tag](../../editors/outliner/editing.xhtml#bpy-ops-outliner-collection-color-tag-set) tool in the Outliner.
user: Explain Make Segment in complete detail according to the official Blender documentation.

assistant: Connects two disconnected control points.
The selection must be loose points, or the first/last point of a curve, then press `F`.
If the points belong to different curves, these are joined by a segment to become a single curve.

|  |  |
| --- | --- |
| ../../../_images/modeling_curves_editing_control-points_two-curves.png   Two curves before. | ../../../_images/modeling_curves_editing_curve_make-segment.png   Curve after joining. |

Note that you can only join curves of the same type (i.e. Bézier with Bézier, NURBS with NURBS).
Additionally, you can close a curve by toggling cyclic.
user: Give a detailed overview of Naming and Nesting: syntax, arguments, return values, common patterns.

assistant: Collections can be named and sorted hierarchically.
Just like folders can have subfolders in any operating system,
collections can have nested collections too.

[image reference removed]

Nested collections.

For example: a *house* collection can contain a *bedroom* collection,
which in turn contains a *furniture* collection referencing a bed, a cabinet and other objects.