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

assistant: Buoyancy Density
:   Buoyant force based on gas density.

    - Values above 0 will cause the gas to rise (simulating gas which is lighter than ambient air).
    - Values below 0 will cause gas to sink (simulating gas which is heavier than ambient air).

Buoyancy Heat
:   Controls how much gas is affected by temperature.
    The effect this setting has on gas depends on the per flow object
    [Initial Temperature](../flow.xhtml#bpy-types-fluidflowsettings-temperature):

    - Values above 0 will result in the gas rising when the flow object *Initial Temperature* is
      set to a positive value, and gas sinking when the flow object *Initial Temperature* is
      set to a negative value.
    - Values below 0 will result in the opposite of positive values,
      i.e. gas emitted from flow objects with a positive *Initial Temperature* will sink,
      and gas from flow objects with a negative *Initial Temperature* will rise.

    Note that gas from multiple flow objects with different temperatures will mix and warm up or
    cool down until an equilibrium is reached.

Vorticity
:   Controls the amount of turbulence in the gas. Higher values will make lots of small swirls,
    while lower values make smoother shapes.

    Comparison of different amounts of vorticity.

    |  |  |
    | --- | --- |
    | ../../../../_images/physics_fluid_type_domain_settings_vorticity-off.png   Domain with a vorticity of 0.0. | ../../../../_images/physics_fluid_type_domain_settings_vorticity-on.png   Domain with a vorticity of 0.2. |

### Dissolve

Allow gas to dissipate over time.

Time
:   Speed of gas dissipation in frames.

Slow
:   Dissolve gas in a logarithmic fashion. Dissolves quickly at first, but lingers longer.
user: What is GeometryNodeFillCurve(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeFillCurve(GeometryNode)

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

*class* bpy.types.GeometryNodeFillCurve(*GeometryNode*)
:   Generate a mesh on the XY plane with faces on the inside of input curves

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

assistant: ### Cycles

The different render passes can be combined to produce the final image as follows:

[image reference removed]

### EEVEE

The passes can be combined to produce the final image as follows:

[image reference removed]
user: What is Chaining and how is it used in Blender Python scripting?

assistant: By default all retrieved lines from the line set are chained together.
There are two basic chaining methods:

Method
:   Plain:
    :   The default chaining method; it creates simple chains.

    Sketchy:
    :   This chaining option allows for generating chains of feature edges with sketchy multiple strokes.
        Basically, it generates *Round* strokes instead of a single one.
        It is only really useful if you use some random-driven modifiers in the line style!

        Rounds
        :   It specifies the number of rounds in sketchy strokes.

Same Object
:   If true, only feature edges of the same object are joined.

Chaining can also be turned off to render each line separately,
which can be useful for line styles which depend on accurate representation of the line set.
user: Show practical ways to work with Usage in a Blender add-on or script – include code.

assistant: [image reference removed]

To Sphere Factor.

As can be seen in the below image, the result
will be smoother and more spherical when there are more mesh elements available to work with.

[image reference removed]

To Sphere applied to cubes with different subdivision levels.

In this image sequence, To Sphere was applied to the entire cube
at levels of 0, 0.25 (25%), 0.5 (50%) and 1 (100%) respectively.

The *To Sphere* transform will generate different results depending on the number
and arrangement of elements that were selected (as shown by the below image).

[image reference removed]

To Sphere applied to different selections.
user: How do I use Data-Block Menu in Blender? Include parameters, examples, warnings and best practices.

assistant: # Data-Block Menu

Lets you select a [Data-Block](../../../files/data_blocks.xhtml) (such as a material)
in order to link it to something else (such as an object).

[image reference removed]

A data-block menu with a search field.

Type
:   Shows an icon indicating the data-block type. Clicking the image or the down arrow opens the popup menu.
    Dragging the image lets you apply the data-block to something else. (For example, you can drag a
    material onto an object in the 3D Viewport to [assign](../../../render/materials/assignment.xhtml) it.
    Dragging onto [Data ID](#ui-data-id) fields is also possible.)

    List
    :   A list of data-blocks available in the current blend-file, or a link to select an item from.
        The menu may show a preview besides the items and
        a search field to search the items in the list by name.

Name
:   Displays, and allows [editing](../../../files/data_blocks.xhtml#data-system-datablock-name-and-rename) of, the name of the selected
    data-block.

User Count
:   Displays the number of [users](../../../glossary/index.xhtml#term-Data-User) of the data (if there’s more than one user).
    Clicking it will create a single-user copy.

    As an example, if three separate objects referenced the same material, the material’s user count would be 3.
    Changing the material would affect all three objects. If you now selected an object and clicked the user count,
    the object would receive its very own copy of the material, which can be modified independently of the original
    that’s still used by the other two.

Fake User (shield icon)
:   If a data-block has no [real users](../../../glossary/index.xhtml#term-Real-User), it’ll normally be cleaned up
    (deleted) when saving the blend-file. To prevent this, you can give it a fake user;
    that way, it’s guaranteed to “survive.” Data-blocks with a fake user have an “F”
    prefix in the drop-down list.

    The [Outliner](../../../editors/outliner/introduction.xhtml) can show an overview of all data-blocks
    without real users in the blend-file. Simply change its Display Mode to Orphan Data.

New/Add (files icon)
:   Creates a new data-block (or duplicates the current one) and selects it.

Open File (folder icon)
:   Opens the [File Browser](../../../editors/file_browser.xhtml), for importing an image for example.

Unpack File (bin icon)
:   [Unpack](../../../files/blend/packed_data.xhtml#pack-unpack-data) the file packed into the current blend-file to an external one.

(Unlink Data-block)
:   Clears the link. `Shift`-`LMB` to set the users to zero
    allowing the data to be fully deleted from the blend-file.

Sometimes there is a [list](list_view.xhtml#ui-list-view) of applied data-blocks
(such as a list of materials used on the object).
user: Provide the full official documentation entry for Snapping, preserving all code examples.

assistant: Snapping aligns the position and size of nodes to the background grid.
This feature allows nodes to snap to a grid, ensuring that node layouts remain clean and visually aligned.
Snapping can be toggling the snap icon (/) in the editor’s headers
or toggled temporarily while [transforming](editing.xhtml#nodes-editing-transform) nodes by holding `Ctrl`.
user: Give a detailed overview of Separate Spherical Node: syntax, arguments, return values, common patterns.

assistant: # Separate Spherical Node

[image reference removed]

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

Spherical coordinates describe a position in 3D space using radius, azimuth (horizontal angle),
and polar (vertical) angle. This representation is useful for procedural effects involving
rotational symmetry, spherical gradients, or direction-based transformations.
user: Explain Bone Collections in complete detail according to the official Blender documentation.

assistant: Manages the [Bone Collections](../../properties/bone_collections.xhtml#bpy-types-bonecollection) the bone is assigned to.

Move to Collection `M`
:   Move bones to a collection.

Assign to Collection `Shift`-`M`
:   Assign all selected bones to a collection, or unassign them,
    depending on whether the active bone is already assigned or not.

---

Show All `Ctrl`-`AccentGrave`
:   Unhides any hidden bone collections.

Assign to new Collection
:   Assigns the selected bones to a new collection named “New Collection”.
    This collection can be renamed in the [Bone Collections](../../properties/bone_collections.xhtml#bpy-types-bonecollection) panel of the Armature properties.
user: Describe ShaderNodeBevel(ShaderNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShaderNodeBevel(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.ShaderNodeBevel(*ShaderNode*)
:   Generates normals with round corners.
    Note: only supported in Cycles, and may slow down renders

    samples
    :   Number of rays to trace per shader evaluation

        Type:
        :   int in [2, 128], default 0

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Path Animation

The *Path Animation* settings can be used to determine how child objects move along a certain path.

[image reference removed]

Path Animation panel.

Frames
:   The number of frames that are needed to traverse the path,
    defining the maximum value for the *Evaluation Time* setting.

Evaluation Time
:   Parametric position along the length of the curve that object following it should be at
    (the position is evaluated by dividing by the *Frames* value).
    By default, it is linked to the global frame number,
    but could be keyframed to give more control over the path animation.

Clamp
:   Clamp the curve path children so they can’t travel past the start/end point of the curve.

Follow
:   Make the curve path children rotate along the curvature of the path.
user: Provide the full official documentation entry for CrossStrip(EffectStrip), preserving all code examples.

assistant: # CrossStrip(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.CrossStrip(*EffectStrip*)
:   Crossfade 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: Describe Internal Springs from the Blender manual or Python API, including usage steps and snippets.

assistant: As stated in the introduction, cloth physics are simulated through [Springs](../introduction.html#physics-cloth-introduction-springs)
connecting vertices on the surface of a mesh. But these springs only interact on the surface
and only apply to 2D surfaces. 3D or *Internal Springs* can be used to make a mesh behave similarly to
a [Soft Body](../../soft_body/index.html). Internal springs can be enabled by toggling the checkbox in
the *Internal Springs* panel header.

Max Spring Creation Length
:   The maximum length an internal spring can have during creation.
    If the distance between internal points is greater than this,
    no internal spring will be created between these points.
    A length of zero means that there is no length limit.

Max Creation Diversion
:   The maximum angle that is allowed to use to connect the internal points can diverge from the vertex normal.

Check Surface Normals
:   Requires the points the internal springs connect to have opposite normal directions.

Tension
:   How much the material resists stretching.

Compression
:   How much the material resists compression.

Vertex Group
:   The *Tension* and *Compression* of internal springs can be controlled via
    a [Vertex Group](../../../modeling/meshes/properties/vertex_groups/index.html) to
    specify which the portions of the mesh have internal springs or the spring strength.

Max Tension
:   Maximum tension stiffness value.

Max Compression
:   Maximum Compression stiffness value.
user: Show practical ways to work with NodeTreeInterfaceSocketFloatTime(NodeTreeInterfaceSocket) in a Blender add-on or script – include code.

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: Show practical ways to work with Updating Extensions in a Blender add-on or script – include code.

assistant: You need to manually check for available updates.
Once an update is found, Blender will let you update any of the available extensions.

The current available version of an extension on the repository will always be considered the latest version.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: Source Channel
:   The channel which the Multicam Selector gets its input from.

Cut To
:   Cuts the Multicam strip at the current frame and
    changes the *Source Channel* automatically to the selected channels.
user: Explain TextureNodeMath(TextureNode) in complete detail according to the official Blender documentation.

assistant: # TextureNodeMath(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.TextureNodeMath(*TextureNode*)
:   operation
    :   Type:
        :   enum in [Node Math Items](bpy_types_enum_items/node_math_items.html#rna-enum-node-math-items), default `'ADD'`

    use_clamp
    :   Clamp result of the node to 0.0 to 1.0 range

        Type:
        :   boolean, default False

    *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 Combine Color Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Combine Color Node

[image reference removed]

The *Combine Color Node* combines an image from its composite color channels.
The node can combine multiple [Color Models](../../../glossary/index.xhtml#term-Color-Model) depending on the Mode property.
user: Provide the full official documentation entry for ShaderNodeTexMagic(ShaderNode), preserving all code examples.

assistant: # ShaderNodeTexMagic(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.ShaderNodeTexMagic(*ShaderNode*)
:   Generate a psychedelic color texture

    color_mapping
    :   Color mapping settings

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

    texture_mapping
    :   Texture coordinate mapping settings

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

    turbulence_depth
    :   Level of detail in the added turbulent noise

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

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is GeometryNodeCornersOfFace(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeCornersOfFace(GeometryNode)

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

*class* bpy.types.GeometryNodeCornersOfFace(*GeometryNode*)
:   Retrieve corners that make up a face

    *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 X/Y/Z Local in a Blender add-on or script – include code.

assistant: These operations perform a non-interactive mirror along the object’s local axes.

X Local
:   Mirrors the selection along the object’s local X axis.

Y Local
:   Mirrors the selection along the object’s local Y axis.

Z Local
:   Mirrors the selection along the object’s local Z axis.
user: Describe Technical Details from the Blender manual or Python API, including usage steps and snippets.

assistant: Blender treats the bone as a section of a Bézier curve passing through the bones’ joints.
Each of the *Segments* will bend and roll to follow this invisible curve
representing a tessellated point of the Bézier curve.
The control points at each end of the curve are the endpoints of the bone.
The shape of the B-Bones can be controlled using a series of properties or
indirectly through the neighboring bones (i.e. first child and parent).
The properties construct handles on either end of the bone to control the curvature.

When using the B-bone as a constraint target [Data ID](../../../../interface/controls/templates/data_block.html#ui-data-id) offers an option to follow the curvature.
user: Describe Resizing from the Blender manual or Python API, including usage steps and snippets.

assistant: [[image reference removed]](../../_images/interface_window-system_areas_resize.png)

You can resize areas by dragging their borders with `LMB`.
Move your mouse cursor over the border between two areas,
so that the cursor changes to a double-headed arrow, and then click and drag.
Hold `Ctrl` to snap the size of areas to convenient sizes.
user: Give a detailed overview of Delta Transforms: syntax, arguments, return values, common patterns.

assistant: Delta Transforms are simply transformations that are applied on top of the transforms described above.
Delta Transforms are particularly useful in animations. For example,
you can animate an object with the primary transforms then move them around with Delta Transforms.
user: Give a detailed overview of Edit Mode: syntax, arguments, return values, common patterns.

assistant: - [Mesh Edit Mode](../../../modeling/meshes/tools/toolbar.html#mesh-toolbar-index)
- [Curve Edit Mode](../../../modeling/curves/tools/toolbar.html#curve-toolbar-index)
- [Surface Edit Mode](../../../modeling/surfaces/toolbar/index.html#surface-toolbar-index)
- [Metaball Edit Mode](../../../modeling/metas/toolbar/index.html#meta-toolbar-index)
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: The inputs of the node are dynamic. In particular, the *Location* input is only available in
the *Texture* and *Point* vector types.

Vector
:   The vector to be transformed.

Location
:   The amount of translation along each axis.

Rotation
:   The amount of rotation along each axis. XYZ order.

Scale
:   The amount of scaling along each axis.
user: Provide the full official documentation entry for Usage, preserving all code examples.

assistant: glTF™ (GL Transmission Format) is used for transmission and loading of 3D models
in web and native applications. glTF reduces the size of 3D models and
the runtime processing needed to unpack and render those models.
This format is commonly used on the web, and has support in various 3D engines
such as Unity3D, Unreal Engine 4, and Godot.

This importer/exporter supports the following glTF 2.0 features:

- Meshes
- Materials (Principled BSDF) and Shadeless (Unlit)
- Textures
- Cameras
- Punctual lights (point, spot, and directional)
- Extensions (listed below)
- Extras (custom properties)
- Animation (keyframe, shape key, and skinning)
user: Give a detailed overview of Scripted Expression - Orbit a Point: syntax, arguments, return values, common patterns.

assistant: Orbit an object’s position around a point with a custom *Scripted Expression*.
The object’s position will change when scrubbing the timeline.
Using trigonometry, circular motion can be defined in 2D using the sine and cosine functions.
(See [Unit Circle](https://en.wikipedia.org/wiki/Unit_circle).)
In this example, the current frame is used as the variable that induces the motion.
`frame` is a [Simple Expression](drivers_panel.html#drivers-simple-expressions) that corresponds to
`bpy.context.scene.frame_current`.

[image reference removed]

1. Add a driver to the X Location property.

   1. Set the *Driver Type* to *Scripted Expression*.
   2. Add the expression `0 + (sin(frame / 8) * 4)`, where:

      - `frame/8` : is the current frame of the animation, divided by 8 to slow the orbit down.
      - `(sin( )*4)` : multiplies the result of `sin(frame/8)` by 4 for a bigger circle.
      - `0 +` : is used to control the offset to the orbit center point.
2. Add a driver to the Y Location property with the expression `0 + (cos(frame / 8) * 4)`.
3. Scrub the timeline to see the effect.
   Experiment with the variables to control the size and center of the orbit.
user: Provide the full official documentation entry for Cloth with Wind, preserving all code examples.

assistant: [[image reference removed]](../../_images/physics_cloth_examples_flag2.jpg)

Flag with wind applied.

Regression blend-file for Cloth with wind and self-collisions (also the blend for the image above):
[Cloth flag with wind and self-collisions](https://archive.blender.org/wiki/2015/index.php/File:Cloth-flag2.blend).
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

UI for a Texture force field.

Texture Mode
:   This sets the way a force vector is derived from the texture.

    Curl:
    :   Calculates the force vector from the curl of the 3D-RGB texture (rotation of RGB vectors).
        This also works only with a color texture. It can be used for example to create a nice looking
        turbulence force with a color clouds texture with Perlin noise.

    Gradient:
    :   Calculates the force vector as the 3D gradient of the intensity (grayscale) of the texture.
        The gradient vector always points to the direction of increasing brightness.

    RGB:
    :   Uses the color components directly as the force vector components in the color encoded directions.
        You need an RGB texture for this, e.g. an image or a color ramp.
        So a *Blend* texture without a color ramp would not suffice.

Nabla
:   It is the offset used to calculate the partial derivatives needed
    for *Gradient* and *Curl* texture modes.

Use Coordinates
:   Uses the emitter object coordinates (and rotation & scale) as the texture space the particles use.
    Allows for moving force fields, that have their coordinates bound to the location coordinates of an object.

Root Texture Coordinates
:   This is useful for hair as it uses the texture force calculated for
    the particle root position for all parts of the hair strand.

2D
:   Disregards the particles Z coordinate and only uses particles X & Y as the texture coordinates.

Remember that only procedural texture are truly 3D.
user: Explain Usage in complete detail according to the official Blender documentation.

assistant: Extrude Point
:   `LMB` click to add a new point connected to the currently selected point.
    The new point will have [handle type](../../../../modeling/curves/structure.xhtml#curve-bezier-handle-type) of *Vector*.
    `Shift`-`LMB` click will add point as type *Auto*.
    However, the handle type switches to *Align* when handles are moved (See *Move Point*).

Delete Point
:   `Ctrl`-`LMB` click on an existing point to delete it.

Insert Point
:   `Ctrl`-`LMB` click on a [Curve Segment](../../../../glossary/index.xhtml#term-Curve-Segment) to insert a new control point between the two
    adjacent control points. `Ctrl`-`LMB` click and drag to control the handles of the inserted points.

Move Segment
:   `LMB` drag on a segment in between two control points to adjust the handles, changing the shape of the
    curve without affecting the location of any control points.

Select Point
:   `LMB` click to select a single point or handle at a time.

Move Point
:   `LMB` drag to move existing points or handles. With an endpoint of a stroke selected,
    click and drag on empty space to *Extrude Point* and move the handle at the same time.

Close Stroke
:   Make the stroke [Cyclic](../../../../glossary/index.xhtml#term-Cyclic) by clicking the endpoints.

Cycle Handle Type
:   Double `LMB` click on the control point to cycle through all handle types.
user: What is GeometryNodePointsToVertices(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodePointsToVertices(GeometryNode)

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

*class* bpy.types.GeometryNodePointsToVertices(*GeometryNode*)
:   Generate a mesh vertex for each point cloud point

    *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 CollectionObject(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # CollectionObject(bpy_struct)

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

*class* bpy.types.CollectionObject(*bpy_struct*)
:   Object of a collection with its collection related settings

    light_linking
    :   Light linking settings of the collection

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Dimensions
:   The dimensions of the space to evaluate the noise in.

    1D:
    :   Evaluate the noise in 1D space at the input *W*.

    2D:
    :   Evaluate the noise in 2D space at the input *Vector*. The Z component is ignored.

    3D:
    :   Evaluate the noise in 3D space at the input *Vector*.

    4D:
    :   Evaluate the noise in 4D space at the input *Vector* and the input *W* as the fourth dimension.

Type
:   Type of Noise texture, with different ways to combine octaves.

    fBM:
    :   Fractal Brownian motion, produces a homogeneous and isotropic result.
        Values from octaves are added together.

    Multifractal:
    :   More uneven, varying by location similar to real terrain.
        Values from octaves are multiplied together.

    Hybrid Multifractal:
    :   Creates peaks and valleys with different roughness values, like real mountains rise out of flat plains.
        Combines octaves using both addition and multiplication.

    Ridged Multifractal:
    :   Creates sharp peaks. Calculates the absolute value of the noise,
        creating “canyons”, and then flips the surface upside down.

    Hetero Terrain:
    :   Similar to *Hybrid Multifractal* creates a heterogeneous terrain, but with the likeness of river channels.

Normalize fBM
:   If enabled, ensures that the output values stay in the range 0.0 to 1.0.
    If disabled, the range is at most -(*Detail* + 1) to *Detail* + 1 (smaller if *Roughness* < 1).
user: Give a detailed overview of Braid Hair Curves: syntax, arguments, return values, common patterns.

assistant: # Braid Hair Curves

The *Braid Hair Curves* node deforms existing hair curves into braided strands by
grouping nearby curves around guide curves. The deformation creates a multi-strand
braid pattern, with options for radius, twist frequency, strand thickness, and an
optional flare or tied ending.

This node is designed for grooming workflows where a few curves act as braid guides,
and surrounding curves are wrapped around them to form a structured braid.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Min
:   The minimum value of the range where random values are sampled from.
    This input is only available for *Float*, *Integer*, and *Vector* types.

Max
:   The maximum value of the range where random values are sampled from.
    This input is only available for *Float*, *Integer*, and *Vector* types.

Probability
:   The probability ratio for the random *Boolean* output to be *True*.
    This input is only available for *Boolean* types.

ID
:   An ID to drive the random number generator seed. By default, this input uses the same value
    as of the [ID Node](../geometry/read/id.xhtml), which is the `id` attribute of the context
    geometry if it exists, and otherwise the [index](../geometry/read/input_index.xhtml).

Seed
:   A field to [Seed](../../../glossary/index.xhtml#term-Seed) the random number generator. This can be used to generate
    a different set of random values, even for two nodes with the same *ID* input.
user: Show practical ways to work with Closure in a Blender add-on or script – include code.

assistant: # Closure

The *Closure* node defines a zone that encapsulates a reusable section of nodes behaving like a function.
It specifies inputs, outputs, and internal logic that can be executed elsewhere in the node tree using an
[Evaluate Closure](../../../../interface/controls/nodes/types/utilities/closure/evaluate_closure.xhtml) node.

Closures allow users to pass custom procedural logic into node groups, making tools more modular and adaptable.
Instead of duplicating or editing an existing group, a closure can expose user-defined behavior while preserving
the structure of the main system.

[image reference removed]

An empty closure zone.
user: Describe World from the Blender manual or Python API, including usage steps and snippets.

assistant: The Viewport Display panel in the World Properties has several settings that
are used by the Workbench Engine.

Color
:   The color of the world background. This color will be rendered
    in the background of the scene.
user: Give a detailed overview of UV Tangent Node: syntax, arguments, return values, common patterns.

assistant: # UV Tangent Node

[image reference removed]

The *UV Tangent* node generates tangent direction vectors based on a specified UV map.
Tangents are unit-length vectors that lie along the surface of the geometry
and point in the direction of increasing *U* coordinates in the UV space.
They are commonly used in shading and texturing workflows, for example in
normal mapping or anisotropic effects.

This node allows for either exact or approximate tangent computation, offering
a balance between precision and performance depending on the use case.
user: Provide the full official documentation entry for Keying Set Panel, preserving all code examples.

assistant: This panel is used to add, select, manage “Absolute Keying Sets”.

[image reference removed]

The Keying Set panel.

Active Keying Set
:   A [List View](../../interface/controls/templates/list_view.xhtml#ui-list-view) of Keying Sets in the active scene.
    Selecting a keying set makes it active

    Add Empty Keying Set
    :   Adds an empty Keying Set.

    Remove Active Keying Set
    :   Removes the active keying set.

Description
:   A short description of the Keying Set.

Export to File
:   Export Keying Set to a Python script `File.py`.
    To re-add the Keying Set from the `File.py`, open then run the `File.py` from the Text Editor.

### Active Keying Set Panel

This panel is used to add properties to the active Keying Set.

[image reference removed]

The Active Keying Set panel.

Paths
:   A collection of paths in a [List View](../../interface/controls/templates/list_view.xhtml#ui-list-view) each with a *Data Path* to a property
    to add to the active Keying Set.

    Add Empty Keying Set Path
    :   Adds an empty path.

    Remove Active Keying Set Path
    :   Removes the selected path.

Target ID-Block
:   Set the ID Type and the *Object IDs* data path for the property.

Data Path
:   Set the rest of the Data Path for the property.

Array All Items
:   Use *All Items* from the Data Path or select the array index for a specific property.

F-Curve Grouping
:   This controls what group to add the channels to.

    Keying Set Name, None, Named Group

### Keyframing Settings

General Override
:   These options control all properties in the Keying Set.
    Note that the same settings in *Preferences* override these settings if enabled.

Active Set Override
:   These options control individual properties in the Keying Set.

Common Settings
:   Needed
    :   Only insert keyframes where they are needed in the relevant F-Curves.

    Visual
    :   Insert keyframes based on the visual transformation.
user: Give a detailed overview of Pop-Up Toolbar: syntax, arguments, return values, common patterns.

assistant: Pressing `Shift`-`Spacebar` will pop up a small toolbar right at
your cursor for faster access.
The shortcuts for selecting the tools are displayed on the right.

Alternatively, you can map this action to `Spacebar` in the Keymap Preferences.
Then you’ll be able use `Spacebar` like a modifier key
(similar to holding `Ctrl` or `Shift`).
For example, you can press `Spacebar` `T` for Transform,
`Spacebar` `D` for Annotate, `Spacebar` `M` for Measure and so on.
See [Spacebar Action](../editors/preferences/keymap.xhtml#keymap-blender-default-spacebar-action).