PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of Mirror: syntax, arguments, return values, common patterns.

assistant: UVs can be mirrored on the Y axis or the X axis:

- Mirror X
- Mirror Y

You can also use the hotkeys `X` or `Y`,
or hold the `MMB` and drag in the mirror direction.

### Copy Mirrored UV Coordinates

Copies UVs from one side of the mirrored mesh to the other.
Affects only selected vertices (on both sides).

Axis Direction
:   Positive/Negative

Precision
:   Tolerance for finding vertex duplicates.
user: Show practical ways to work with Socket Syncing in a Blender add-on or script – include code.

assistant: Closure nodes use socket names to match their inputs and outputs.
If two closure nodes are connected but have mismatched signatures, Blender can offer to sync them automatically.

- Sync happens automatically when a node is connected for the first time.
- Existing sockets are never changed automatically to avoid overwriting user data.
- A  button (*Sync Sockets*) button appears in the node header when a mismatch is detected, allowing manual synchronization.
user: How do I use Strip Color Items in Blender? Include parameters, examples, warnings and best practices.

assistant: # Strip Color Items

NONE:
:   None.

    Assign no color tag to the collection.

COLOR_01:
:   Color 01.

COLOR_02:
:   Color 02.

COLOR_03:
:   Color 03.

COLOR_04:
:   Color 04.

COLOR_05:
:   Color 05.

COLOR_06:
:   Color 06.

COLOR_07:
:   Color 07.

COLOR_08:
:   Color 08.

COLOR_09:
:   Color 09.
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: ### Collapse

[image reference removed]

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]

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]

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: How do I use Randomize in Blender? Include parameters, examples, warnings and best practices.

assistant: # Randomize

[image reference removed]

Randomize transform options.

This tool randomizes the move, rotate, and scale values to an object or multiple objects.
When applied on multiple objects, each object gets its own seed value,
and will get different transform results from the rest.

Random Seed
:   The random seed is an offset to the randomized transformation.
    A different seed will produce a new result.

Transform Delta
:   Randomize [Delta Transform](../../properties/transforms.xhtml#bpy-types-object-delta)
    values instead of regular transform.

Randomize Location
:   Randomize Location values.

Location
:   The maximum distances the objects can move along each axis.

Randomize Rotation
:   Randomize rotation values.

Rotation
:   The maximum angle the objects can rotate on each axis.

Randomize Scale
:   Randomize scale values.

Scale Even
:   Use the same scale for each axis.

Scale
:   The maximum scale randomization over each axis.
user: What is Light Path Node and how is it used in Blender Python scripting?

assistant: # Light Path Node

[image reference removed]

The *Light Path* node is used to find out for which kind of incoming ray the shader is being executed;
particularly useful for non-physically-based tricks. More information about the meaning of each type
is in the [Light Paths](../../cycles/render_settings/light_paths.html) documentation.
user: Explain Adding Scene Strips in complete detail according to the official Blender documentation.

assistant: Existing scenes can be added from the Add ‣ Scene ‣ “Scene Name”.
Additionally, any scene asset in the current file or in an [Asset Library](../../../../files/asset_libraries/introduction.xhtml) will also show up in the Add ‣ Scene.
If a scene asset is assigned to a [Catalog](../../../../files/asset_libraries/catalogs.xhtml), the catalog hierarchy will show up as a sub-menu.
When adding a scene asset as a strip, the scene is always appended/duplicated.

New scenes can also be created directly from the add menu with Add ‣ Scene ‣ Empty Scene.

Options

Start Frame
:   The first frame to start the scene strip.

Channel
:   The channel to place the strip in.

Replace Selection
:   Replace the active strip with the new scene strip.

When creating a new scene you have the following options:

Type
:   How the new scene is created.

    New:
    :   Add new Strip with a new empty Scene with default settings.

    Copy Settings:
    :   Add a new Strip, with an empty scene, and copy settings from the current scene.

    Linked Copy:
    :   Add a Strip and link in the collections from the current scene (shallow copy).

    Full Copy:
    :   Add a Strip and make a full copy of the current scene.
user: Show practical ways to work with Cloth with Animated Vertex Groups in a Blender add-on or script – include code.

assistant: Cloth with animated pinned vertices:
[Regression blend-file](https://archive.blender.org/wiki/2015/index.php/File:Cloth_anim_vertex.blend).
Unsupported: Starting with a goal of 0 and increasing it,
but still having the vertex not pinned will **not** work (e.g. from goal = 0 to goal = 0.5).
user: Give a detailed overview of Transforms: syntax, arguments, return values, common patterns.

assistant: Applying transforms resets an object’s *Location*, *Rotation*, or *Scale* values
while visually keeping the object in place.
In practice, this means:

- The object’s origin is moved to the global origin (for location).
- Rotation values are cleared to zero.
- Scale values are reset to 1.0.

The geometry itself is adjusted so that the object continues to appear unchanged in the 3D Viewport
and final render.

For simple cases you may not notice a difference,
but applying transforms can affect how modifiers, constraints, and parenting behave,
since they often depend on an object’s transform values.

### Options

Location
:   Apply (set) the location of the selection.
    This will make Blender consider the current location to be equivalent to 0 in each plane
    i.e. the selection will not move, the current location will be considered to be the “default location”.
    The object origin will be set to actual (0, 0, 0) (where the colored axis lines intersect in each view).

Rotation
:   Apply (set) the rotation of the selection.
    This will make Blender consider the current rotation to be equivalent to 0 degrees in each plane
    i.e. the selection will not rotated, the current rotation will be considered to be the “default rotation”.

Scale
:   Apply (set) the scale of the selection.
    This will make Blender consider the current scale to be equivalent to 0 in each plane
    i.e. the selection will not scaled, the current scale will be considered to be the “default scale”.

Rotation & Scale
:   Apply (set) the rotation and scale of the selection. Do the above two applications simultaneously.

Apply Properties
:   Modify properties such as curve vertex radius, font size and bone envelope
    according to the applied transformation. (Found in the [Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel)
user: Give a detailed overview of Pixel Density: syntax, arguments, return values, common patterns.

assistant: The pixel density (often called [PPI](../../../glossary/index.xhtml#term-PPI) or [DPI](../../../glossary/index.xhtml#term-DPI)) controls the intended physical size for an image.
This is often used for printing or the physical size when loaded into desktop publishing software.

The X/Y density is calculated using the render X/Y aspect,
making these values useful for storing the aspect ratio of non-square pixels.

The pixel-density is meta-data which doesn’t impact the quality of the image.
user: Give a detailed overview of Retime Node: syntax, arguments, return values, common patterns.

assistant: # Retime Node

[image reference removed]

The *Retime* node controls the timing of input sequences, animations, or time-based effects
by offsetting, skipping, or repeating frames.
It can be used to create time remapping effects such as slow motion, fast-forward, looping,
or rhythmic stutter effects within a compositing setup.
user: Provide the full official documentation entry for AlphaUnderStrip(EffectStrip), preserving all code examples.

assistant: # AlphaUnderStrip(EffectStrip)

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

*class* bpy.types.AlphaUnderStrip(*EffectStrip*)
:   Alpha Under Strip

    input_1
    :   First input for the effect strip

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

    input_2
    :   Second input for the effect strip

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for BlendDataObjects(bpy_struct), preserving all code examples.

assistant: # BlendDataObjects(bpy_struct)

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

*class* bpy.types.BlendDataObjects(*bpy_struct*)
:   Collection of objects

    new(*name*, *object_data*)
    :   Add a new object to the main database

        Parameters:
        :   - **name** (*string**,* *(**never None**)*) – New name for the data-block
            - **object_data** ([`ID`](bpy.types.ID.html#bpy.types.ID "bpy.types.ID")) – Object data or None for an empty object

        Returns:
        :   New object data-block

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

    remove(*object*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove an object from the current blendfile

        Parameters:
        :   - **object** ([`Object`](bpy.types.Object.html#bpy.types.Object "bpy.types.Object"), (never None)) – Object to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of this object before deleting it
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this object
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this object

    tag(*value*)
    :   tag

        Parameters:
        :   **value** (*boolean*) – Value

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

assistant: # Introduction

Rigify helps automate the creation of character rigs. It is based around a building-block approach,
where you build complete rigs out of smaller rig parts (e.g. arms, legs, spines, fingers…).
The rig parts are currently few in number, but as more rig parts are added to
Rigify it should become more and more capable of rigging a large variety of characters and creatures.

Rigify also operates on the principle that once a rig is created, that rig should no longer need Rigify.
This means you can always distribute rigs created with Rigify to people
who do not have it and the rigs will still function completely.

It is important to note that Rigify only automates the creation of the rig controls and bones.
It does not attach the rig to a mesh, so you still have to do skinning etc. yourself.
user: Provide the full official documentation entry for PaintCurve(ID), preserving all code examples.

assistant: # PaintCurve(ID)

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

*class* bpy.types.PaintCurve(*ID*)
:   *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 NodeSocketVector2D(NodeSocketStandard), preserving all code examples.

assistant: # NodeSocketVector2D(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.NodeSocketVector2D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   float array of 2 items in [-inf, inf], default (0.0, 0.0)

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

assistant: # Toolbar

Selection tools
:   [Tweak](../../../interface/selecting.xhtml#tool-select-tweak)
    :   Select or move.

    [Select Box](../../../interface/selecting.xhtml#tool-select-box)
    :   Select strips by dragging a box.
        All strips that intersect the box will be selected.

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

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

Blade
:   Cuts a strip in two. Specifically, it first shortens the strip so it only shows the content
    up to the cut point, then adds a second strip that shows the content after the cut point.

    Splitting be done in two different ways:

    - Select the tool in the Toolbar and click a strip at the time point where you want to split it.
    - Alternatively, select one or more strips, place the Playhead at the time point where you want to
      split them, and press one of the keyboard shortcuts below.

    You can choose between the following split types:

    Soft `K`
    :   After splitting, it’s still possible to restore the cut content in the new strips
        by dragging their handles.

    Hard `Shift`-`K`
    :   After splitting, it’s not possible to restore the cut content by dragging handles.
        However, you can still restore it by changing the [Hold Offset](sidebar/strip.xhtml#sequencer-duration-hard)
        in the Sidebar.

Slip
:   Moves only the content of the strip. By default, the tool only allows the content to be moved within
    strip handles. If this limit applies, the strip outline is drawn in red color. By pressing `C`
    the limiting is toggled on or off.
user: How do I use TextureNodeTexStucci(TextureNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # TextureNodeTexStucci(TextureNode)

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

*class* bpy.types.TextureNodeTexStucci(*TextureNode*)
:   *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Docking describes several ways an area a user can interactively manipulate
the size and location of areas along with splitting an area into new areas.

To start the interactive process, placing the mouse cursor
in an area corner will change the cursor to a cross (+).
Once the cursor is a cross, press and hold `LMB` to preform any of the following actions:

If you press `Esc` or `RMB` before releasing the mouse, the operation will be canceled.

### Joining

[image reference removed]

Properties is being joined to the Outliner.

Dragging from an area corner into the space of a second area will *join* two areas.
The areas that will be joined will be displayed brighter.

### Splitting

[image reference removed]

Splitting an area will create a new area.
Dragging from an area corner left/right will split the area vertically,
to split the area horizontally drag up/down.

You can split and join areas at once by dragging a split operation into a separate area.

Dragging an area into the middle of an second area will replace the second area with the first area.
user: What is Fluid Modifier and how is it used in Blender Python scripting?

assistant: # Fluid Modifier

The Fluid modifier is a container for a [Fluid Physics](../../../physics/fluid/index.html) simulation. It can be useful
for example, to simulate on a low-poly mesh then add a [Subdivision Surface Modifier](../generate/subdivision_surface.html)
after the Fluid modifier to improve the visual quality of the fluid without drastically increasing simulation times.
user: How do I use CopyLocationConstraint(Constraint) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CopyLocationConstraint(Constraint)

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

*class* bpy.types.CopyLocationConstraint(*Constraint*)
:   Copy the location of the target

    head_tail
    :   Target along length of bone: Head is 0, Tail is 1

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

    invert_x
    :   Invert the X location

        Type:
        :   boolean, default False

    invert_y
    :   Invert the Y location

        Type:
        :   boolean, default False

    invert_z
    :   Invert the Z location

        Type:
        :   boolean, default False

    subtarget
    :   Armature bone, mesh or lattice vertex group, …

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

    target
    :   Target object

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

    use_bbone_shape
    :   Follow shape of B-Bone segments when calculating Head/Tail position

        Type:
        :   boolean, default False

    use_offset
    :   Add original location into copied location

        Type:
        :   boolean, default False

    use_x
    :   Copy the target’s X location

        Type:
        :   boolean, default False

    use_y
    :   Copy the target’s Y location

        Type:
        :   boolean, default False

    use_z
    :   Copy the target’s Z location

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Import OBJ Node

[image reference removed]

The *Import OBJ* node loads geometry data from a .obj file and outputs it as instances.

Each object defined in the OBJ file is imported as a separate instance,
which helps to preserve scene structure and optimize performance.
This approach allows for efficient manipulation and reuse of the geometry within Geometry Nodes workflows.

This node is useful for importing static 3D assets created in other modeling software.
user: How do I use Manual Storage in Blender? Include parameters, examples, warnings and best practices.

assistant: It is also possible to manually manage brushes in blend-files like any other asset data-block. By
marking brushes as assets and saving the file in an asset library, they become available from any
Blender session. This gives full control over how assets are stored, and is particularly useful for
curating asset libraries that can be shared with others.

[[image reference removed]](../../_images/sculpt-paint_brush_brush-management_mark-as-asset.png)

The *Mark as Asset* operator used on a brush in the Outliner.

Brushes can be imported as normal data-blocks from other files (including from .asset.blend files
from an asset library) through [appending](../../files/linked_libraries/link_append.html#bpy-ops-wm-append). In the
[Blender File](../../editors/outliner/interface.html#outliner-blender-file-mode) mode of the Outliner, the brush will be listed
under *Brushes*. Right-click the brush and select *Mark as Asset*. By saving the file inside of
an asset library directory, the asset becomes available from all Blender sessions. If necessary,
configure an asset library directory in the Preferences.
user: Describe Image Texture Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Image Texture Node

[image reference removed]

The *Image Texture* node is used to add an image file as a texture.
The image data is sampled with the input Vector and outputs a Color and Alpha value.
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.xhtml)
for compositing.

[image reference removed]

Nodes in the Compositor.

The use of the Compositor is explained in [Compositing](../compositing/index.xhtml).
user: Show practical ways to work with Tool Settings in a Blender add-on or script – include code.

assistant: Filter Type
:   Fill:
    :   Fills in a single color.

    Hue:
    :   Shifts the Hue of each color.

    Saturation:
    :   Increases or decreases the saturation.

    Value:
    :   Increases or decreases the values.

    Brightness:
    :   Increases or decreases the brightness.

    Contrast:
    :   Increases or decreases the contrast.

    Smooth:
    :   Blurs or sharpens the colors.

    Red:
    :   Increases or decreases the red channel.

    Green:
    :   Increases or decreases the green channel.

    Blue:
    :   Increases or decreases the blue channel.

Fill Color
:   Set a color that will be used for the fill filter type.

Strength
:   The amount of effect the filter has on the color attribute.
user: What is Arguments and how is it used in Blender Python scripting?

assistant: - [Render Options](arguments.xhtml#command-line-args-render-options)
- [Cycles Render Options](arguments.xhtml#command-line-args-cycles-render-options)
- [Format Options](arguments.xhtml#command-line-args-format-options)
- [Animation Playback Options](arguments.xhtml#command-line-args-animation-playback-options)
- [Window Options](arguments.xhtml#command-line-args-window-options)
- [Python Options](arguments.xhtml#command-line-args-python-options)
- [Network Options](arguments.xhtml#command-line-args-network-options)
- [Logging Options](arguments.xhtml#command-line-args-logging-options)
- [Debug Options](arguments.xhtml#command-line-args-debug-options)
- [GPU Options](arguments.xhtml#command-line-args-gpu-options)
- [Misc Options](arguments.xhtml#command-line-args-misc-options)
user: Describe FunctionNodeCombineTransform(FunctionNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # FunctionNodeCombineTransform(FunctionNode)

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

*class* bpy.types.FunctionNodeCombineTransform(*FunctionNode*)
:   Combine a translation vector, a rotation, and a scale vector into a transformation matrix

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Geometry
:   Standard geometry input.

Selection
:   Boolean field for specifying which elements should be selected in the output geometry.
    Elements for which this field evaluates to false are implicitly de-selected.
user: Describe Clear from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Before

Deletes all tracked and keyframed markers after the current frame for all selected tracks.

Clear Active
:   Limits clear action to only active track (as opposite to all selected ones).

### After

Deletes all tracked and keyframed markers before the current frame for all selected tracks.

Clear Active
:   Limits clear action to only active track (as opposite to all selected ones).

### Track Path

Clears all markers except the current one from all selected tracks.

Clear Active
:   Limits clear action to only active track (as opposite to all selected ones).

### Clear Solution
user: Give a detailed overview of Shade Auto Smooth: syntax, arguments, return values, common patterns.

assistant: Adds a [Smooth By Angle Modifier](../../../modeling/modifiers/normals/smooth_by_angle.xhtml) to automatically set
the sharpness of mesh edges based on the angle between the neighboring faces.
Note, the modifier will be [pinned](../../../modeling/modifiers/introduction.xhtml#bpy-types-modifier-use-pin-to-last) to be the last modifier.

Auto Smooth
:   If disabled, any [Smooth By Angle Modifiers](../../../modeling/modifiers/normals/smooth_by_angle.xhtml) are removed.

Angle
:   Maximum angle between face normals that will be considered as smooth.
user: Give a detailed overview of Visibility: syntax, arguments, return values, common patterns.

assistant: Type
:   Determine how to use visibility for feature edge selection.

    Visible:
    :   Only lines occluded by no surfaces are rendered.

    Hidden:
    :   Lines occluded by at least one surface are rendered.

        [[image reference removed]](../../../_images/render_freestyle_parameter-editor_line-set_visibility-hidden-edges.png)

        Proof of concept of visible and hidden edges by LightBWK
        ([blend-file](https://archive.blender.org/wiki/2015/index.php/File:HiddenCreaseEdgeMark.zip)).

    Quantitative Invisibility:
    :   Lines occluded by a number of surfaces in the given range are rendered.

        Start, End
        :   Min/max number of occluding surfaces for a line to be rendered.

        [[image reference removed]](../../../_images/render_freestyle_parameter-editor_line-set_visibility-qi-range.png)

        QI Range proof of concept demo, Start: 3, End: 7, by LightBWK
        ([blend-file](https://archive.blender.org/wiki/2015/index.php/File:QI-Range.zip)).
user: What is Bpy.Types.Actionslot and how is it used in Blender Python scripting?

assistant: Markers(bpy_struct) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page ActionSlot(bpy_struct) ActionSlot ActionSlot.active ActionSlot.handle ActionSlot.identifier ActionSlot.name_display ActionSlot.select ActionSlot.show_expanded ActionSlot.target_id_type ActionSlot.target_id_type_icon ActionSlot.users() ActionSlot.duplicate() ActionSlot.bl_rna_get_subclass() ActionSlot.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Direction
:   A vector that defines the reference direction to compare against the element normals.
    The direction should typically be normalized.

Threshold
:   The maximum angular difference between the element normal and the given direction
    for the element to be included in the selection.
user: What is Mesh Primitives and how is it used in Blender Python scripting?

assistant: # Mesh Primitives

Meshes are the most common object type used in 3D scenes.
Blender provides a variety of built-in mesh primitives that serve as starting points for modeling.
These primitives can be added in both Object Mode and Edit Mode, where they appear at the location of the 3D Cursor.

[image reference removed]

Blender’s standard mesh primitives.
user: What is NodeTreeInterfaceSocketFloatTime(NodeTreeInterfaceSocket) and how is it used in Blender Python scripting?

assistant: # NodeTreeInterfaceSocketFloatTime(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.NodeTreeInterfaceSocketFloatTime(*NodeTreeInterfaceSocket*)
:   Floating-point number socket of a node

    default_value
    :   Input value used for unconnected socket

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

    max_value
    :   Maximum value

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

    min_value
    :   Minimum value

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

    subtype
    :   Subtype of the default value

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: |  |  |
| --- | --- |
| - [`CurveMap.points`](bpy.types.CurveMap.html#bpy.types.CurveMap.points "bpy.types.CurveMap.points") - [`CurveMapPoints.new`](bpy.types.CurveMapPoints.html#bpy.types.CurveMapPoints.new "bpy.types.CurveMapPoints.new") | - [`CurveMapPoints.remove`](bpy.types.CurveMapPoints.html#bpy.types.CurveMapPoints.remove "bpy.types.CurveMapPoints.remove") |
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Image
:   Standard color input.

Crypto Passes
:   Each crypto layer will be given its own render pass;
    each of these render passes must be connected to one of these crypto layer inputs.
    By default there are only four layers, see [Adding/Removing Layers](#adding-removing-layers) to add more.
user: How do I use LineStyleGeometryModifier_BackboneStretcher(LineStyleGeometryModifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # LineStyleGeometryModifier_BackboneStretcher(LineStyleGeometryModifier)

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

*class* bpy.types.LineStyleGeometryModifier_BackboneStretcher(*LineStyleGeometryModifier*)
:   Stretch the beginning and the end of stroke backbone

    backbone_length
    :   Amount of backbone stretching

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    type
    :   Type of the modifier

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

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleGeometryModifier_BackboneStretcher.type "bpy.types.LineStyleGeometryModifier_BackboneStretcher.type")
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

Curves and [Surfaces](../surfaces/introduction.xhtml) are particular types of Blender objects.
They are expressed by mathematical functions (interpolation)
rather than linear interpolation between a series of points.

Blender offers both [Bézier](structure.xhtml#curve-bezier) and [NURBS](structure.xhtml#curve-nurbs).
Both Bézier curves and NURBS curves and surfaces are defined in terms of a set of “control points”
(or “control vertices”) which define a “control polygon”.

[image reference removed]

Blender logo made from Bézier curves.

Both Bézier and NURBS curves are named after their mathematical definitions, and
choosing between them is often more a matter of how they are computed behind the scenes
than how they appear from a modeler’s perspective.
Bézier curves are generally more intuitive because they start and end at the control points that you set,
but NURBS curves are more efficient for the computer to calculate when there are many twists and turns in a curve.

The main advantage to using curves instead of polygonal meshes is that curves are defined by
less data and so can produce results using less memory and storage space at modeling time.
However, this procedural approach to surfaces can increase demands at render time.

Certain modeling techniques, such as
[extruding a profile along a path](properties/geometry.xhtml),
are possible only using curves. On the other hand, when using curves,
vertex-level control is more difficult and if fine control is necessary,
[mesh editing](../meshes/editing/introduction.xhtml) may be a better modeling option.

Bézier curves are the most commonly used curves for designing letters or logos.

They are also widely used in animation, both as for objects to move along (see constraints below)
and as [F-Curves](../../editors/graph_editor/fcurves/introduction.xhtml)
to change the properties of objects as a function of time.
user: Explain Euler Modes in complete detail according to the official Blender documentation.

assistant: The axes system used for performing Euler rotations is the so called Euler gimbal.
A gimbal is a particular set of three axes.
The special thing about this is that the axes have a hierarchical relationship between them:
one of the axes is at the top of the hierarchy, and has one of the other two axes as its immediate child;
at the same time, this child axis is the parent of the remaining axis, the one at the very bottom of the hierarchy.

Which axis is on top, which one in the middle and which at the bottom,
depends on the particular Euler gimbal: there are six types of them, as there
are six possible combinations: XYZ, XZY, YXZ, YZX, ZXY and ZYX Euler rotation modes.
These modes are named using the letters of the axes in order, starting from
the axis at the bottom of the hierarchy, and finishing with the one on top.

The main problem of these systems comes when they lose their relative perpendicularity.
And this happens when the axis in the middle rotates, causing the axis at the bottom to
rotate with it. It keeps getting worse when this bottom axis approaches 90° (or equivalent angles).
In that case, it will remain aligned with the axis on top of the hierarchy. In that moment
we have just lost one axis of rotation. This can cause discontinuous interpolations when animating.
This particular loss of axis is known as the “gimbal lock”.

One advantage of this mode is that animation curves are easy to understand and edit.
However, special attention must be done when the middle axis approaches values close to 90° (or equivalent angles).
user: How do I use VFX Platform in Blender? Include parameters, examples, warnings and best practices.

assistant: Blender follows the [VFX reference platform](https://vfxplatform.com),
which means it is able to run on the same systems as other VFX software
and exchange image, volume and scene files with them.

### Python Version

Blender and the [bpy module](https://pypi.org/project/bpy/) are only compatible
with a single Python version. This makes it possible for add-ons and VFX software
in general to only have to target a single Python version.

Blender bundles a complete Python installation and does not interact with the
system Python by default. This can be changed with the `--python-use-system-env`
[command line argument](command_line/arguments.xhtml#command-line-args-python-options), if care is
taken to set up a compatible Python version.
user: Provide the full official documentation entry for Stack, preserving all code examples.

assistant: # Stack

The list of constraints affecting an object or bone is called the *Constraint Stack*.
It’s evaluated from top to bottom, and reordering it can drastically change the outcome.

[image reference removed]

Moving constraints is done by dragging their handle  with `LMB`.
user: Show practical ways to work with Edit Mode in a Blender add-on or script – include code.

assistant: - [Mesh Edit Mode](../../../modeling/meshes/tools/toolbar.xhtml#mesh-toolbar-index)
- [Curve Edit Mode](../../../modeling/curves/tools/toolbar.xhtml#curve-toolbar-index)
- [Surface Edit Mode](../../../modeling/surfaces/toolbar/index.xhtml#surface-toolbar-index)
- [Metaball Edit Mode](../../../modeling/metas/toolbar/index.xhtml#meta-toolbar-index)
user: Give a detailed overview of Curve of Point Node: syntax, arguments, return values, common patterns.

assistant: # Curve of Point Node

[image reference removed]

The *Curve of Point* node retrieves the index of the curve a control point is part of.
This node is conceptually similar to the [Face of Corner Node](../../mesh/topology/face_of_corner.xhtml).
user: Explain Tool Settings in complete detail according to the official Blender documentation.

assistant: Radius
:   Control newly added point’s radius.

Stroke Placement
:   The [Stroke Placement](../../draw/stroke_placement.xhtml) of newly added points.

Drawing Plane
:   The [Drawing Planes](../../draw/drawing_planes.xhtml) of newly added points.
user: Provide the full official documentation entry for Simulation Zone, preserving all code examples.

assistant: # Simulation Zone

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.

[image reference removed]

Initial simulation nodes and simulation zone.

When adding a simulation, two nodes are added, defining between them a “Simulation Zone”.

The inputs that are connected to the Simulation Input node are evaluated only once,
at the beginning of the simulation, passed to the next simulation state and eventually outputted.
Other nodes can be linked inside the simulation region from the outside.
Those are re-evaluated every step based on their value at the given frame.

It is not possible to have any link going towards outside.
The result of the simulation can only be accessed via the Simulation Output node.
This also allows sub-frame interpolation for motion blur.