PGCRYPT/OpenBlender_Train huggingface dataset:
user: Show practical ways to work with Gizmogroup Operators in a Blender add-on or script – include code.

assistant: # Gizmogroup Operators

bpy.ops.gizmogroup.gizmo_select(*\**, *extend=False*, *deselect=False*, *toggle=False*, *deselect_all=False*, *select_passthrough=False*)
:   Select the currently highlighted gizmo

    Parameters:
    :   - **extend** (*boolean**,* *(**optional**)*) – Extend, Extend selection instead of deselecting everything first
        - **deselect** (*boolean**,* *(**optional**)*) – Deselect, Remove from selection
        - **toggle** (*boolean**,* *(**optional**)*) – Toggle Selection, Toggle the selection
        - **deselect_all** (*boolean**,* *(**optional**)*) – Deselect On Nothing, Deselect all when nothing under the cursor
        - **select_passthrough** (*boolean**,* *(**optional**)*) – Only Select Unselected, Ignore the select action when the element is already selected

bpy.ops.gizmogroup.gizmo_tweak()
:   Tweak the active gizmo
user: Show practical ways to work with Examples in a Blender add-on or script – include code.

assistant: ### Open 2D Curve

An open (non-cyclic) curve with beveling applied becomes a tube.

[image reference removed]

### Closed 2D Curve

A closed (cyclic) curve with beveling applied becomes a torus by default.
If the curve is 2D and you set the [Fill Mode](shape.xhtml#bpy-types-curve-fill-mode) to *Both*,
the top and bottom holes will be filled with flat discs, and you’ll get a cylinder
with rounded edges instead.

[image reference removed]

This doesn’t work with 3D curves.

### Taper

By selecting a 2D curve as the *Taper Object* of another (2D or 3D) curve,
you can let the radius of the latter curve’s geometry vary over the curve’s
length without having to create additional control points.

[image reference removed]

### Tilt

You can use the [Tilt](../editing/control_points.xhtml#modeling-curve-tilt) tool to rotate a control point around
its tangent axis, creating a twist in the curve. The example below also uses
a custom profile (cross section).

[image reference removed]
user: Show practical ways to work with Show/Hide in a Blender add-on or script – include code.

assistant: When in *Edit Mode*, you can hide and reveal elements from the display.
You can only show or hide control points, as segments are always shown,
unless all control points of the connected curve are hidden,
in which case the curve is fully hidden.

See [Show/Hide](../../../scene_layout/object/editing/show_hide.html#object-show-hide) in *Object Mode*.
See also the [Curve Display](../curve_display.html) panel.
user: Give a detailed overview of Numeric Input: syntax, arguments, return values, common patterns.

assistant: # Numeric Input

Using the mouse for transformations is convenient, but if you require more precise control,
you can also enter numeric values. After pressing the shortcut type a number
to indicate the magnitude of the transformation. Then confirm or cancel.
E.g. pressing `S` `2`, `Return` will double the scale of an object.

Move `G`
:   By default and with no other key presses, the translation will occur along the X axis.

Rotation `R`
:   The rotation is in clockwise direction for positive values.

Scale `S`
:   Scaling works in almost identical fashion to translation.
    The primary difference is that by default, scaling applies equally to all three axes.

You can see the numbers you enter in the 3D Viewport footer.

[image reference removed]

Numeric input displayed in the footer.
user: Give a detailed overview of Bpy.Types.Greasepencilsimplifymodifier: syntax, arguments, return values, common patterns.

assistant: ree_node_filter GreasePencilSimplifyModifier.use_layer_group_filter GreasePencilSimplifyModifier.use_layer_pass_filter GreasePencilSimplifyModifier.use_material_pass_filter GreasePencilSimplifyModifier.vertex_group_name GreasePencilSimplifyModifier.bl_rna_get_subclass() GreasePencilSimplifyModifier.bl_rna_get_subclass_py() Inherited Properties Inherited Functions
user: Show practical ways to work with Asset Operators in a Blender add-on or script – include code.

assistant: Brushes can be managed through a few operators that let Blender handle the act of saving and
updating the brushes in asset libraries for you. Assets managed this way will be saved in special
[asset system files](../../files/asset_libraries/introduction.xhtml#asset-system-files) using a .asset.blend file extension.

[image reference removed]

Brush Asset panel in the Sidebar showing asset operators.

Duplicate Asset…
:   Creates a copy of the currently active brush as asset, and activates it. A popup is spawned to input some settings
    to use:

    Name
    :   A custom name to use for the new brush.

    Library
    :   Choose an Asset Library to store the new brush asset in. The available asset libraries are configured
        [in the Preferences](../../editors/preferences/file_paths.xhtml#bpy-types-userassetlibrary).

    Catalog
    :   Choose an [Asset Catalog](../../files/asset_libraries/catalogs.xhtml) to assign the brush asset to. Entering a
        non-existent name/path will create a new catalog accordingly.

Delete Asset
:   Permanently remove this brush asset from the Asset Library it is stored in. This cannot be undone, so a popup will
    ask for confirmation.

Edit Metadata…
:   Spawns a popup to change some of the available [asset metadata](../../editors/asset_browser.xhtml#editing-asset-metadata) fields:

    Catalog
    :   Choose an [Asset Catalog](../../files/asset_libraries/catalogs.xhtml) to assign the brush asset to. Entering a
        non-existent name/path will create a new catalog accordingly.

    Author
    :   See [Asset Author](../../editors/asset_browser.xhtml#bpy-types-assetmetadata-description).

    Description
    :   See [Asset Description](../../editors/asset_browser.xhtml#bpy-types-assetmetadata-description).

Edit Preview Image…
:   Opens a window with the File Browser to select an image for the asset preview.

Save Changes to Asset
:   Saves any changes made to the active brush to the asset library.

Revert to Asset
:   Discards any unsaved changes made to the brush asset.
user: Describe Channels from the Blender manual or Python API, including usage steps and snippets.

assistant: # Channels

A channel is a horizontal track that’s similar to a layer in an image editing program:
higher channels are displayed in front of lower ones.

Within each channel, you can create one or more
[strips](../../../video_editing/edit/montage/strips/introduction.xhtml), which contain either
a segment of video content (a rendered scene, an external video file…)
or an [effect](../../../video_editing/edit/montage/strips/effects/index.xhtml)
(color blending, blurring…). The X axis represents time, so the further a strip
is placed to the right, the later it will play in the final video.

While a channel can contain multiple strips, they can’t overlap each other.
If you want two strips to play at the same time, you need to place them in different channels.
user: Give a detailed overview of Splitting: syntax, arguments, return values, common patterns.

assistant: You can split up chains of Freestyle lines by enabling one of the following:

Min/Max 2D Angle
:   Splits chains of feature edges when they make a 2D angle above (or below) a minimum (or maximum) threshold.

2D Length
:   Splits chains when they are longer than the given value.

Material Boundary
:   Splits chains of feature edges if they cross from one material to another.

### Split Pattern

Splits the chains using the given dashed pattern (see also [Dashed Line](#dashed-line)).

Dash 1, 2, 3
:   Length of the specified dash for splitting.

Gap 1, 2, 3
:   Length of the specified gap for splitting.
user: Describe What is a Pose Asset? from the Blender manual or Python API, including usage steps and snippets.

assistant: A *pose asset* is an action that has been [marked as asset](../../../../files/asset_libraries/introduction.html#asset-create),
and that contains exactly **one frame of animation** data.
Usually these are created via the *Create Pose Asset* button (see below),
but any action that is keyed on exactly one frame can be seen as pose asset.

Each pose in the library is stored in its own action data-block.
This means that it can get its own name, its own preview image,
and can be organized in [Asset Catalogs](../../../../files/asset_libraries/catalogs.html).

Since a pose asset is just an action, it can also contain
[slots](../../../actions.html#animation-actions-slots). That means a single pose asset
can contain a pose for more than one armature. When applying
the pose, the best matching slot for the given armature will be chosen
to read the pose from. If no good match can be found it will fall back
to the first slot. For generic pose assets, it is recommended to use single-slot actions.
That way Blender always uses the first (and only) slot, regardless of which
character the pose is applied to. If a pose is specific to two
or more characters, they can be stored in the same asset for convenience.
For info on how to create such multi-character pose assets see [Pose Creation](#pose-creation).
user: Show practical ways to work with ShaderNodeBsdfGlass(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeBsdfGlass(ShaderNode)

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

*class* bpy.types.ShaderNodeBsdfGlass(*ShaderNode*)
:   Glass-like shader mixing refraction and reflection at grazing angles

    distribution
    :   Light scattering distribution on rough surface

        - `BECKMANN`
          Beckmann.
        - `GGX`
          GGX.
        - `MULTI_GGX`
          Multiscatter GGX – GGX with additional correction to account for multiple scattering, preserve energy and prevent unexpected darkening at high roughness.

        Type:
        :   enum in [`'BECKMANN'`, `'GGX'`, `'MULTI_GGX'`], default `'BECKMANN'`

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

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

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 4 items in [-inf, inf], default (0.0, 0.0, 0.0, 0.0)

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 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: What is FileBrowserFSMenuEntry(bpy_struct) and how is it used in Blender Python scripting?

assistant: # FileBrowserFSMenuEntry(bpy_struct)

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

*class* bpy.types.FileBrowserFSMenuEntry(*bpy_struct*)
:   File Select Parameters

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

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

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

    use_save
    :   Whether this path is saved in bookmarks, or generated from OS

        Type:
        :   boolean, default False, (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 References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`ThemeClipEditor.space`](bpy.types.ThemeClipEditor.html#bpy.types.ThemeClipEditor.space "bpy.types.ThemeClipEditor.space") - [`ThemeConsole.space`](bpy.types.ThemeConsole.html#bpy.types.ThemeConsole.space "bpy.types.ThemeConsole.space") - [`ThemeDopeSheet.space`](bpy.types.ThemeDopeSheet.html#bpy.types.ThemeDopeSheet.space "bpy.types.ThemeDopeSheet.space") - [`ThemeFileBrowser.space`](bpy.types.ThemeFileBrowser.html#bpy.types.ThemeFileBrowser.space "bpy.types.ThemeFileBrowser.space") - [`ThemeGraphEditor.space`](bpy.types.ThemeGraphEditor.html#bpy.types.ThemeGraphEditor.space "bpy.types.ThemeGraphEditor.space") - [`ThemeImageEditor.space`](bpy.types.ThemeImageEditor.html#bpy.types.ThemeImageEditor.space "bpy.types.ThemeImageEditor.space") - [`ThemeInfo.space`](bpy.types.ThemeInfo.html#bpy.types.ThemeInfo.space "bpy.types.ThemeInfo.space") - [`ThemeNLAEditor.space`](bpy.types.ThemeNLAEditor.html#bpy.types.ThemeNLAEditor.space "bpy.types.ThemeNLAEditor.space") - [`ThemeNodeEditor.space`](bpy.types.ThemeNodeEditor.html#bpy.types.ThemeNodeEditor.space "bpy.types.ThemeNodeEditor.space") | - [`ThemeOutliner.space`](bpy.types.ThemeOutliner.html#bpy.types.ThemeOutliner.space "bpy.types.ThemeOutliner.space") - [`ThemePreferences.space`](bpy.types.ThemePreferences.html#bpy.types.ThemePreferences.space "bpy.types.ThemePreferences.space") - [`ThemeProperties.space`](bpy.types.ThemeProperties.html#bpy.types.ThemeProperties.space "bpy.types.ThemeProperties.space") - [`ThemeSequenceEditor.space`](bpy.types.ThemeSequenceEditor.html#bpy.types.ThemeSequenceEditor.space "bpy.types.ThemeSequenceEditor.space") - [`ThemeSpreadsheet.space`](bpy.types.ThemeSpreadsheet.html#bpy.types.ThemeSpreadsheet.space "bpy.types.ThemeSpreadsheet.space") - [`ThemeStatusBar.space`](bpy.types.ThemeStatusBar.html#bpy.types.ThemeStatusBar.space "bpy.types.ThemeStatusBar.space") - [`ThemeTextEditor.space`](bpy.types.ThemeTextEditor.html#bpy.types.ThemeTextEditor.space "bpy.types.ThemeTextEditor.space") - [`ThemeTopBar.space`](bpy.types.ThemeTopBar.html#bpy.types.ThemeTopBar.space "bpy.types.ThemeTopBar.space") |
user: Describe Limited Dissolve from the Blender manual or Python API, including usage steps and snippets.

assistant: This tool can simplify your mesh by dissolving vertices and edges separating flat regions.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_mesh_delete_limited-dissolve-before.png   Original mesh. | ../../../../_images/modeling_meshes_editing_mesh_delete_limited-dissolve-after.png   Result of Limited Dissolve. |

Max Angle
:   Reduces detail on planar faces and linear edges with an adjustable angle threshold.

All Boundaries
:   Always dissolve vertices that have two edge users at boundaries.

Delimit
:   Prevent faces from joining when they don’t share certain properties (material for e.g.).
user: Provide the full official documentation entry for Create Plane Track, preserving all code examples.

assistant: The *Create Plane Track* operator creates a new plane track.
Planar tracking takes advantage of the fact that there are often planar surfaces in footage,
by attaching markers to points on these flat planes.
It can be used to replace things like billboards and screens on the footage with another image or video.
It also might be used for masking.

This button will create a plane object
which is deforming in the same way as plane defined by all selected point tracks.
At least four feature points tracked across the footage which belongs to
the plane you want to replace are needed. More tracks will give better estimation of plane motion.

Feature points used to estimate plane motion could be used from any place on the plane,
meaning it’s not necessarily need to be corners. Corners are not always easy to be tracked,
they might be occluded. In this case you can position tracked features that lay on the same plane
far away from the actual plane which should be replaced.

This provides more information about the possible deformation of the marker in following frames,
and such markers can be tracked even if partially occluded (appear and disappear during the time).
It is only required that two neighbor frames have at least four common tracks.

An image can be projected onto the plane with
the [Plane Track Deform Node](../../../../compositing/types/tracking/plane_track_deform.xhtml) compositing node.
user: Show practical ways to work with Modifying a Pose Asset in a Blender add-on or script – include code.

assistant: A pose asset can be modified after it has been created.
This is only possible for pose assets in the current file or that have been exported into
an .asset.blend file.
For that, an operator has been created which can be accessed by right clicking a pose asset.
That operator works on the active object, so updating the asset from selected bones
of multiple armatures won’t work. It will find the best matching slot, falling back to
the first one.
There are 4 modes.

Adjust Pose
:   Update existing channels in the pose asset from the selected bones,
    but don’t remove or add any channels.

Replace
:   Completely replace all channels in the pose asset with the channels of the selected bones.

Add
:   Add channels of the selected bones to the pose asset. Existing channels will be updated.

Remove
:   Remove channels of the selected bones from the pose asset.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Rotation
:   The [Euler](../../../../glossary/index.html#term-Euler) rotation to align.

Factor
:   Determines how much the points are rotated towards the vector.
    Zero effectively disables the node and one means that the points are aligned with the vector perfectly.

Vector
:   The direction vector that points should be rotated to.
    The vector is in the local space of the object that is being modified.
    When it is all zeros for a point, it is not rotated at all.
user: Give a detailed overview of References: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`BlendData.palettes`](bpy.types.BlendData.html#bpy.types.BlendData.palettes "bpy.types.BlendData.palettes") - [`BlendDataPalettes.new`](bpy.types.BlendDataPalettes.html#bpy.types.BlendDataPalettes.new "bpy.types.BlendDataPalettes.new") | - [`BlendDataPalettes.remove`](bpy.types.BlendDataPalettes.html#bpy.types.BlendDataPalettes.remove "bpy.types.BlendDataPalettes.remove") - [`Paint.palette`](bpy.types.Paint.html#bpy.types.Paint.palette "bpy.types.Paint.palette") |
user: Show practical ways to work with FunctionNodeMatrixDeterminant(FunctionNode) in a Blender add-on or script – include code.

assistant: # FunctionNodeMatrixDeterminant(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.FunctionNodeMatrixDeterminant(*FunctionNode*)
:   Compute the determinant of the given 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: How do I use CompositorNodeHueSat(CompositorNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CompositorNodeHueSat(CompositorNode)

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

*class* bpy.types.CompositorNodeHueSat(*CompositorNode*)
:   Apply a color transformation in the HSV color model

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: This setting controls how the normals (visualized as arrows)
twist around each control point – so it is only relevant with 3D curves!
The tilt will be interpolated from point to point (you can check it with the normals).

[image reference removed]

30 degree Mean Tilt of all control points.
user: Provide the full official documentation entry for Screw, preserving all code examples.

assistant: # Screw

The *Screw* operator extrudes geometry along a helix. You can use it to create screws, springs,
sea shells and so on.

While it’s similar to the [Screw Modifier](../../../modifiers/generate/screw.xhtml),
there are some important differences:

| Screw operator | Screw modifier |
| --- | --- |
| Works in world space. | Works in object space. |
| Extrudes only the selected geometry. | Extrudes all geometry. |
| The centerpoint can be specified manually. | The centerpoint is always the object’s origin. |
| One revolution is always 360°. | The angle can be chosen freely. |
| The height offset of each revolution is calculated automatically based on the geometry. | The height offset must be specified manually. |
| Each revolution can also have a radial offset away from/towards the central axis (again determined by the geometry). | The radius stays constant. |

As described above, the Screw operator automatically determines the height offset and radial
offset to apply after each revolution. It does this by looking for the endpoints of an open profile –
a series of connected edges that don’t form a closed loop. The geometry is extruded so that the
profile’s top vertex in one revolution will coincide with the bottom vertex in the next.

The most common use case is extruding such an open profile. You’re not limited to this, however.
As long as there is one open profile in the selection – even just a single loose edge –
you can also extrude closed profiles and even geometry with faces.

You can see some examples below.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_screw_example-shell.png   Wood Screw. | ../../../../_images/modeling_meshes_editing_edge_screw_example-spring.png   Spring. |
user: Provide the full official documentation entry for Main View, preserving all code examples.

assistant: ### Adjusting the View

Use these shortcuts to adjust the view:

- Pan: `MMB`
- Horizontal scroll: use `Ctrl`-`Wheel`, or drag the horizontal scrollbar.
- Vertical scroll: use `Shift`-`Wheel`, or drag the vertical scrollbar.
- Zoom: `Wheel`
- Scale view: `Ctrl`-`MMB` and drag left/right (horizontal scale) or up/down (vertical scale).
  Alternatively, you can drag the circles on the scrollbars with `LMB`.

### Playhead

The Playhead is the blue vertical line with the current time at the top. To see how to interact with it
see the [Playhead](../../../animation/animation_editors.html#playhead) documentation. In addition to that, the Video
Sequencer has a special case where if you start dragging on a strip, that strip will be highlighted
and displayed *solo* in the preview (all other strips are temporarily muted).

If scrubbing (or regular playback) performs poorly, you can speed it up by creating
[proxies](sidebar/proxy.html).
user: Describe Saving your Composite Image from the Blender manual or Python API, including usage steps and snippets.

assistant: The *Render* button renders a single frame or image.
Save your image using [Save Image](../editors/image/editing.xhtml#bpy-ops-image-save).
The image will be saved using the image format settings on the Render panel.

To save a sequence of images, for example,
if you input a movie clip or used a Time node with each frame in its own file,
use the *Animation* button and its settings. If you might want to later overlay them,
be sure to use an image format that supports an Alpha channel (such as `PNG`).
If you might want to later arrange them front to back or create a depth of field effect,
use a format that supports a Z-depth channel (such as `EXR`).

To save a composition as a movie clip (all frames in a single file),
use an `AVI` or `QuickTime` format, and use the *Animation* button and its settings.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Geometry
:   The input geometry containing the hair curves to modify.

Cumulative Offset
:   When enabled, each point’s offset depends on the displacement of previous points along the curve.
    This results in more natural and continuous bending.

Factor
:   Controls the overall blending strength of the effect.
    A value of 0.0 applies no frizz, while 1.0 applies the full random displacement.

Distance
:   Scales the magnitude of the random displacement applied to the curve points.

Shape
:   Determines how the displacement strength changes along the length of each curve.
    A value of 0.0 applies a constant effect, while 0.5 results in a linear falloff from root to tip.

Seed
:   Defines the random seed used to generate unique displacement patterns.
    Changing this value alters the random variation between curves.

Preserve Length
:   When enabled, maintains the original length of each curve during deformation.
    When disabled, curves may stretch or shrink slightly as a result of the frizz.
user: Give a detailed overview of Index Switch Node: syntax, arguments, return values, common patterns.

assistant: # Index Switch Node

[image reference removed]

The *Index Switch* node outputs one of its inputs based on an integer *Index* value.
Only the selected input is evaluated, making this node useful for switching between
multiple data inputs efficiently.
user: Describe Additional Workflows from the Blender manual or Python API, including usage steps and snippets.

assistant: 2D Grab Brush
:   If the [Falloff Shape](../../brush/falloff.xhtml#bpy-types-brush-falloff-shape) is set to *Projected*,
    the brush can grab infinitely deep into the viewport.
    This is especially useful for much broader changes to a sculpt.

    [image reference removed]

    The stroke can also be started outside of the mesh (like in empty 3D space)
    and grab the vertices within the brush radius.
    This can be useful for sculpting flat and tube-like meshes.
user: Provide the full official documentation entry for TextureNodeTexWood(TextureNode), preserving all code examples.

assistant: # TextureNodeTexWood(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.TextureNodeTexWood(*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: Show practical ways to work with Visibility in a Blender add-on or script – include code.

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]

        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]

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

assistant: # LineStyleColorModifier_DistanceFromCamera(LineStyleColorModifier)

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

*class* bpy.types.LineStyleColorModifier_DistanceFromCamera(*LineStyleColorModifier*)
:   Change line color based on the distance from the camera

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

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

    color_ramp
    :   Color ramp used to change line color

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

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

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

    range_max
    :   Upper bound of the input range the mapping is applied

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

    range_min
    :   Lower bound of the input range the mapping is applied

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

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Color Modifier Type Items](bpy_types_enum_items/linestyle_color_modifier_type_items.html#rna-enum-linestyle-color-modifier-type-items), default `'ALONG_STROKE'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleColorModifier_DistanceFromCamera.type "bpy.types.LineStyleColorModifier_DistanceFromCamera.type")
user: What is Interpolate and how is it used in Blender Python scripting?

assistant: When you are animating simple shapes you can use the interpolate tool
to automatically add new breakdown keyframes.

See [Interpolate tool](../modes/draw/tools/interpolate.html#tool-grease-pencil-draw-interpolate) for more details.
user: Explain Tune Image Node in complete detail according to the official Blender documentation.

assistant: # Tune Image Node

[image reference removed]

The *Tune Image* node provides a quick and intuitive way to enhance an image’s overall appearance
by adjusting key visual parameters such as contrast, clarity, and sharpness.
It is designed as a compact, all-in-one correction tool for fine-tuning rendered or composited images
without requiring multiple separate nodes.
user: Explain ShaderFxPixel(ShaderFx) in complete detail according to the official Blender documentation.

assistant: # ShaderFxPixel(ShaderFx)

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

*class* bpy.types.ShaderFxPixel(*ShaderFx*)
:   Pixelate effect

    size
    :   Pixel size

        Type:
        :   int array of 2 items in [1, 32767], default (0, 0)

    use_antialiasing
    :   Antialias pixels

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

assistant: All field nodes work in the context of the data flow node they are connected to.
The context usually consists of a geometry component type and an attribute domain,
so it determines what data is retrieved from input nodes.

One common misunderstanding is that the same field node tree used in multiple places will
output the same data. This is not necessarily true, because the field node tree will be evaluated
for every data flow node, potentially retrieving data from a different or changed geometry.

[image reference removed]

Here, the [Set Position](geometry/write/set_position.xhtml) node’s
input field is evaluated once. To evaluate the field, the node traverses
backwards to retrieve the inputs from the field input nodes.

[image reference removed]

When a second Set Position node is added, the same field node tree is evaluated twice, once for each data flow node.
At the second Set Position node, the results will be different since its geometry input will already have
the changed position from the first node.

[image reference removed]

However, often it’s necessary to use the same field values even after changing the geometry.
The [Capture Attribute Node](attribute/capture_attribute.xhtml) evaluates a field, copying
the result to an [anonymous attribute](attributes_reference.xhtml#anonymous-attributes) on the geometry.

Here, a Capture Attribute node stores a copy of the initial position.
Notice that evaluating the field input of the Capture Attribute node is an entirely
different step. Later on, the input fields to the Set Position nodes don’t use
the actual position, but the anonymous attribute copy of it.
user: Provide the full official documentation entry for Erase Brushes, preserving all code examples.

assistant: Erase brushes are the special types of brushes that uses Grease Pencil for *Erase* tools.
The brush can be changed in the Tool Settings.
Soft and hard eraser brushes are settings variations of the same *Erase Brush*.
You can create many brushes, each with unique settings to get different effects while erasing.
The *Erase Brush* has also other two special eraser types: point and stroke.
user: What is Bevel Vertices and how is it used in Blender Python scripting?

assistant: # Bevel Vertices

The *Bevel* tool rounds off edges or corners of a mesh at the point of the selected vertices.
In “vertex only” mode, the *Bevel Vertices* tool works on selected vertices
but the option to switch to *Bevel Edges* is available.
By doing so, more vertices are added in order to smooth out profiles with a specified number of *segments*
(see the options below for details about the bevel algorithm).

[image reference removed]

Cubes with and without bevel.
user: Explain Denoise Node in complete detail according to the official Blender documentation.

assistant: # Denoise Node

[image reference removed]

The Denoise node is used to denoise renders from [Cycles](../../../render/cycles/index.xhtml)
and other ray tracing renderers. This helps to significantly reduce render time by
rendering with fewer samples.

It uses [Open Image Denoise](https://www.openimagedenoise.org/),
which transforms noisy images into clean images with machine learning.
user: How do I use Outputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Location
:   Location of the object in world space.

Color
:   Object color, same as *Color* in the Properties ‣ Object Properties ‣ Viewport Display.

Alpha
:   The [Alpha Channel](../../../glossary/index.html#term-Alpha-Channel) component of the object’s viewport display color (see the *Color* output for
    more details).

Object Index
:   Object pass index, same as *Pass Index*
    in the Properties ‣ Object Properties ‣ Relations.

Material Index
:   Material pass index, same as *Pass Index*
    in the Properties ‣ Material ‣ Settings.

Random
:   Random number unique to a single object instance. Output is a Float between 0.0 and 1.0
user: What is Collisions and how is it used in Blender Python scripting?

assistant: # Collisions

In most cases, a piece of cloth does not just hang there in 3D space,
it collides with other objects in the environment. To ensure proper simulation,
there are several items that have to be set up and working together:

- The *Cloth* object must be told to participate in collisions.
- Optionally (but recommended) tell the cloth to collide with itself.
- Other objects must be visible to the *Cloth* object *via* shared layers.
- The other objects must be mesh objects.
- The other objects may move or be themselves deformed by other objects (like an armature or shape key).
- The other mesh objects must be told to deflect the cloth object.
- The blend-file must be saved in a directory so that simulation results can be saved.
- You then *Bake* the simulation. The simulator computes the shape of the cloth for a frame range.
- You can then edit the simulation results, or make adjustments to the cloth mesh, at specific frames.
- You can make adjustments to the environment or deforming objects,
  and then re-run the cloth simulation from the current frame forward.

[image reference removed]

Cloth Collisions panel.

Quality
:   A general setting for how fine and good a simulation you wish.
    Higher numbers take more time but ensure less tears and penetrations through the cloth.
user: What is Light Falloff and how is it used in Blender Python scripting?

assistant: In reality light in a vacuum will always fall off at a rate of 1/(distance^2).
However, as distance goes to zero,
this value goes to infinity and we can get very bright spots in the image.
These are mostly a problem for indirect lighting, where the probability of hitting such
a small but extremely bright spot is low and so happens only rarely.
This is a typical recipe for [Fireflies](../../../glossary/index.xhtml#term-Fireflies).

|  |  |
| --- | --- |
| ../../../_images/render_cycles_optimizations_reducing-noise_falloff-hard.jpg   Hard Falloff. | ../../../_images/render_cycles_optimizations_reducing-noise_falloff-soft.jpg   Soft Falloff. |

To reduce this problem, the [Light Falloff](../../shader_nodes/color/light_falloff.xhtml)
node has a *Smooth factor*, that can be used to reduce the maximum intensity
a light can contribute to nearby surfaces. The images above show default falloff and smooth value 1.0.
user: Show practical ways to work with Transform in a Blender add-on or script – include code.

assistant: An F-Curve can be edited by transforming the locations of its keyframes.

Move, Rotate, Scale
:   Like other elements in Blender, keyframes can be
    moved, rotated, and scaled as described in
    [Basic Transformations](../../../scene_layout/object/editing/transform/introduction.xhtml).

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

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

While transforming keyframes, you can hold `Shift` to move them more slowly for
better precision, or `Ctrl` to move them in coarse increments.