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

assistant: # Vertex Groups

The Vertex groups panel allows you to specify vertex groups to use for several child particle settings.
You can also negate the effect of each vertex group with the checkboxes.
You can affect the following attributes:

Density
:   Defines the density of the particle distribution.

Length
:   Defines the length of the hair.

Clump
:   Controls the amount of clumping.
    The weight of 1.0 gives current *Clump* value, weight of 0.0 completely removes effect.

Kink
:   Controls the frequency of the children Kink.

Roughness 1
:   Adjusts the *Uniform* roughness parameter.

Roughness 2
:   Adjusts the *Random* roughness parameter.

Roughness End
:   Adjusts the *Endpoint* roughness parameter.

Twist
:   Vertex group to control the children’s *Twist* effect.
    Gives control over the direction of the twist, as well as the amount.
    The weight of 0.5 is neutral, i.e. there is no twist effect.
user: Give a detailed overview of Boundary: syntax, arguments, return values, common patterns.

assistant: # Boundary

Similar to the [Pose](pose.xhtml) brush
but deforms the open boundaries of a mesh.
The tool detects the mesh boundary closest to the active vertex and
propagates the deformation using the brush [Falloff](../../brush/falloff.xhtml) into the mesh.

The main use cases of this brush are the *Bend* and *Expand* geometry,
which leads to the best results on evenly distributed quad based topology.
Use the *Inflate*, *Grab*, *Twist*, and *Smooth* deformation modes,
to further adjustments and tweaks to the result
(which do not depend that much on a clean topology).

The boundary origin is displayed via a white line, which indicates the reach of the deformation.
The targeted boundary that will be deformed is highlighted in the brush cursor color.

If the [Deformation Target](../../brush/brush_settings.xhtml#bpy-types-brush-deform-target)
is changed, the brush can also be used for cloth sculpting.
user: Provide the full official documentation entry for Textures, preserving all code examples.

assistant: Limit Size
:   Limit the maximum resolution for pictures used in textured display to save memory.
    The limit options are specified in a square of pixels
    (e.g: the option 256 means a texture of 256×256 pixels). This is useful for game engineers,
    whereas the texture limit matches paging blocks of the textures in the target graphic card memory.

Anisotropic Filtering
:   Sets the level of anisotropic filtering.
    This improves the quality of textures that are rendered at the cost of performance.

Clip Alpha
:   Clip alpha below this threshold in the 3D Viewport.
    Note that, the default is set to a low value to prevent issues on some GPUs.

Image Display Method
:   Method to render images; the following options are supported:

    Automatic:
    :   Automatically use *GLSL* which runs on the GPU for performance but falls back to
        the CPU for large images which might be slow when loaded with the GPU.

    2D Texture:
    :   Uses CPU for display transform and render images as a 2D texture.

    GLSL:
    :   Fastest method using GLSL for display transform and render images as a 2D texture.
user: Give a detailed overview of Socket Syncing: syntax, arguments, return values, common patterns.

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

- Sync happens automatically when a node is connected for the first time.
- Existing sockets are never changed automatically to avoid overwriting user data.
- A  button (*Sync Sockets*) button appears in the node header when a mismatch is detected, allowing manual synchronization.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: The *Evaluate Closure* node does not have functional properties, but its input and output interface can be managed in
the *Node* tab of the Sidebar.

Sync Sockets
:   Updates the current node to match the socket signature of the connected nodes.
    Use this after renaming, adding, or removing sockets.

Define Signature
:   Marks the node as defining a closure signature to be used by other closure nodes. Ensures consistent input and output
    definitions across related closures.

### Input Items

List of input sockets
:   Displays one entry per socket defined in the closure. Double-click to rename.

Add Item
:   Add a new input socket to the closure interface.

Remove Item
:   Delete the selected input socket.

Type
:   The data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value field appears and is used when the socket is unlinked.

Shape
:   Defines the data structure supported by the input socket, such as a *Single* value, *Field*, or *Grid*.
    The shape determines how the data is evaluated and passed through the node network.
    See [Socket Shape](../../../parts.xhtml#interface-controls-nodes-socket-shape) for more information.

### Output Items

List of output sockets
:   Displays one entry per output socket. Double-click to rename.

Add Item
:   Add a new output socket to the node.

Remove Item
:   Delete the selected output socket.

Type
:   The data type for the selected socket (e.g. Float, Vector, Geometry, Object, Bundle).
    For value types, a default value field appears and is used when the socket is unlinked.
user: Provide the full official documentation entry for Arguments, preserving all code examples.

assistant: - [Render Options](arguments.html#command-line-args-render-options)
- [Cycles Render Options](arguments.html#command-line-args-cycles-render-options)
- [Format Options](arguments.html#command-line-args-format-options)
- [Animation Playback Options](arguments.html#command-line-args-animation-playback-options)
- [Window Options](arguments.html#command-line-args-window-options)
- [Python Options](arguments.html#command-line-args-python-options)
- [Network Options](arguments.html#command-line-args-network-options)
- [Logging Options](arguments.html#command-line-args-logging-options)
- [Debug Options](arguments.html#command-line-args-debug-options)
- [GPU Options](arguments.html#command-line-args-gpu-options)
- [Misc Options](arguments.html#command-line-args-misc-options)
user: Give a detailed overview of limbs.front_paw: syntax, arguments, return values, common patterns.

assistant: Derivative of [limbs.paw](#limbs-paw) with extended IK suitable for use in front paws.
The additional IK limits the degree of change in the angle between shin and
paw bones (2nd and 3rd) as the main IK control moves and rotates.

For best results, the shin bone should not be parallel to either thigh or paw in rest pose,
i.e. there should be some degree of bend in all joints of the paw.

Heel IK Influence
:   Influence of the extended IK. At full rotating the main IK control or digit bone would
    not affect the rotation of the paw bone, while lower values provide some blending.
user: Provide the full official documentation entry for SequencerCacheOverlay(bpy_struct), preserving all code examples.

assistant: # SequencerCacheOverlay(bpy_struct)

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

*class* bpy.types.SequencerCacheOverlay(*bpy_struct*)
:   show_cache
    :   Visualize cached images on the timeline

        Type:
        :   boolean, default False

    show_cache_final_out
    :   Visualize cached complete frames

        Type:
        :   boolean, default False

    show_cache_raw
    :   Visualize cached raw images

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

assistant: # Multiply Strip

The *Multiply* effect multiplies two colors.
Blender uses values between (0.0 to 1.0) for the colors.
This operation does not have to be normalized, the multiplication of two terms
between (0.0 to 1.0) always gives a result between (0.0 to 1.0).

(With the “traditional” representation of three bytes, like RGB(124, 255, 56),
the multiplications give far too high results, like RGB(7316, 46410, 1848),
that have to be normalized (brought back) by dividing them by 256
to fit in the range of (0 to 255)…)

This effect has two main usages:

With a Mask

A mask is a black-and-white picture which, after multiplication with a “normal” image,
only show this one in the white areas of the mask (everything else is black).

The opening title sequence to James Bond movies,
where the camera is facing down the barrel of a gun at James, is a good example of this effect.

With Uniform Colors

Multiplying a color with a “normal” image allows you to soften some hues of this one
(and so – symmetrically – to enhance the others).

For example, if you have a brown pixel RGB(0.50, 0.29, 0.05), and
you multiply it with a cyan filter (uniform color RGB(0.0, 1.0, 1.0)), you will get a color RGB(0.0, 0.29, 0.05).
Visually, the result is to zero the reds and bring up (by “symmetry” – the real values remain unchanged!)
the blues and greens. Physically, it is the same effect as shining a cyan light onto a chocolate bar. Emotionally,
vegetation becomes more lush, water becomes more Caribbean and inviting, skies become friendlier.
user: How do I use TextureNodeValToNor(TextureNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # TextureNodeValToNor(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.TextureNodeValToNor(*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: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeForeachGeometryElementOutput.generation_items`](bpy.types.GeometryNodeForeachGeometryElementOutput.html#bpy.types.GeometryNodeForeachGeometryElementOutput.generation_items "bpy.types.GeometryNodeForeachGeometryElementOutput.generation_items") - [`NodeGeometryForeachGeometryElementGenerationItems.new`](bpy.types.NodeGeometryForeachGeometryElementGenerationItems.html#bpy.types.NodeGeometryForeachGeometryElementGenerationItems.new "bpy.types.NodeGeometryForeachGeometryElementGenerationItems.new") | - [`NodeGeometryForeachGeometryElementGenerationItems.remove`](bpy.types.NodeGeometryForeachGeometryElementGenerationItems.html#bpy.types.NodeGeometryForeachGeometryElementGenerationItems.remove "bpy.types.NodeGeometryForeachGeometryElementGenerationItems.remove") |
user: Give a detailed overview of In-Betweens: syntax, arguments, return values, common patterns.

assistant: # In-Betweens

[image reference removed]

In-Betweens Tools.

There are several tools for editing poses in an animation.

There are also in *Pose Mode* a bunch of armature-specific editing options/tools,
like [auto-bones naming](../../bones/editing/naming.html#armature-editing-naming-bones),
[properties switching/enabling/disabling](../../bones/editing/properties.html#armature-bone-properties), etc.,
that were already described in the armature editing pages. See the links above…
user: How do I use FunctionNodeProjectPoint(FunctionNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # FunctionNodeProjectPoint(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.FunctionNodeProjectPoint(*FunctionNode*)
:   Project a point using a matrix, using location, rotation, scale, and perspective divide

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

assistant: # NodeTreeInterfaceSocketFloatTimeAbsolute(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.NodeTreeInterfaceSocketFloatTimeAbsolute(*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: Describe Cache from the Blender manual or Python API, including usage steps and snippets.

assistant: # Cache

In order to improve real-time response and avoid unnecessary recalculation of particles,
the particle data can be cached in memory or stored on a drive.

The *Emitter* particle system uses a unified system for caching and baking (together with Soft Body and Cloth).

[image reference removed]

Particles Cache settings.
user: Provide the full official documentation entry for Catalog Definition Files, preserving all code examples.

assistant: Asset catalogs are stored in Catalog Definition Files (CDFs). Blender 3.0 supports a single CDF per asset library.
It is stored in `blender_assets.cats.txt` in the root directory of the asset library. If the file does not exist,
Blender will create it when the catalogs are saved. When catalogs are changed, Blender updates that file, but also
creates a backup of the previous state to a file named `blender_assets.cats.txt~`.

### Which File to Write To

Asset catalogs can be saved independently of the blend-file; the catalog editor has its own “Save” button.

### Format

Catalog Definition Files (CDFs) are relatively simple text files, encoded in UTF-8.
Each CDF consists of a version indicator, and a line of text per catalog.
Each catalog line is colon-separated, of the form `{UUID}:{path}:{simple name}`.

### Example

This is an example of a valid catalog definition file:

```
# This is an Asset Catalog Definition file for Blender.
#
# Empty lines and lines starting with `#` will be ignored.
# The first non-ignored line should be the version indicator.
# Subsequent lines are of the format "CATALOG_UUID:catalog/path/for/assets:simple catalog name"

VERSION 1

313ea471-7c81-4de6-af81-fb04c3535d0e:catalog/without/simple/name:
ee9c7b60-02f1-4058-bed6-539b8d2a6d34:character/Ellie/poselib:character-Ellie-poselib
cd66bf52-58f4-45cb-a4e2-dc0e0ee8f3fe:character/Ellie/poselib:character-Ellie
4eb44ec6-3424-405b-9782-ca006953e799:character/Ellie/poselib/white space:character-Ellie-poselib-white space
b63ed357-2511-4b96-8728-1b5a7093824c:character/Ružena/poselib:Ružena pose library
dcdee4df-926e-4d72-b995-33106983bb9a:character/Ružena/poselib/face:Ružena face
fb698f2e-9e2b-4146-a539-3af292d44899:character/Ružena/poselib/hand:Ružena hands
```

### Valid Catalog Paths

Catalog paths follow the following rules:

- All paths are absolute; there is no difference between `/a/b` and `a/b`.
- Only `/` as separator (no `\`; think less filesystem path and more URL).
- Not empty (it’s required for a valid catalog).
- No empty components (so not `a//b`; `a/b` is fine).
- Invalid characters: `:`, `\`.
- Paths are always interpreted as UTF-8.
user: Show practical ways to work with Custom Properties in a Blender add-on or script – include code.

assistant: Custom properties can also be assigned to point cloud objects themselves.
These properties are stored at the object level and not per point.

See the [Custom Properties](../../files/custom_properties.xhtml#files-data-blocks-custom-properties)
documentation for more information on how to add and use them.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Geometry
:   Standard geometry input.

Selection
:   Whether to change the material index for each face.
    True values mean the material index will be changed, false values mean it will remain the same.

Material Index
:   The new material index.
user: Describe Strip Video Modifier Type Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Strip Video Modifier Type Items

BRIGHT_CONTRAST:
:   Brightness/Contrast.

COLOR_BALANCE:
:   Color Balance.

COMPOSITOR:
:   Compositor.

CURVES:
:   Curves.

HUE_CORRECT:
:   Hue Correct.

MASK:
:   Mask.

TONEMAP:
:   Tone Map.

WHITE_BALANCE:
:   White Balance.
user: Describe AssetMetaData(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # AssetMetaData(bpy_struct)

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

*class* bpy.types.AssetMetaData(*bpy_struct*)
:   Additional data stored for an asset data-block

    active_tag
    :   Index of the tag set for editing

        Type:
        :   int in [-32768, 32767], default 0

    author
    :   Name of the creator of the asset

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

    catalog_id
    :   Identifier for the asset’s catalog, used by Blender to look up the asset’s catalog path. Must be a UUID according to RFC4122.

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

    catalog_simple_name
    :   Simple name of the asset’s catalog, for debugging and data recovery purposes

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

    copyright
    :   Copyright notice for this asset. An empty copyright notice does not necessarily indicate that this is copyright-free. Contact the author if any clarification is needed.

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

    description
    :   A description of the asset to be displayed for the user

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

    license
    :   The type of license this asset is distributed under. An empty license name does not necessarily indicate that this is free of licensing terms. Contact the author if any clarification is needed.

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

    tags
    :   Custom tags (name tokens) for the asset, used for filtering and general asset management

        Type:
        :   [`AssetTags`](bpy.types.AssetTags.html#bpy.types.AssetTags "bpy.types.AssetTags") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`AssetTag`](bpy.types.AssetTag.html#bpy.types.AssetTag "bpy.types.AssetTag"), (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: |  |  |
| --- | --- |
| - [`XrActionMapBindings.find`](bpy.types.XrActionMapBindings.html#bpy.types.XrActionMapBindings.find "bpy.types.XrActionMapBindings.find") - [`XrActionMapBindings.new`](bpy.types.XrActionMapBindings.html#bpy.types.XrActionMapBindings.new "bpy.types.XrActionMapBindings.new") - [`XrActionMapBindings.new_from_binding`](bpy.types.XrActionMapBindings.html#bpy.types.XrActionMapBindings.new_from_binding "bpy.types.XrActionMapBindings.new_from_binding") - [`XrActionMapBindings.new_from_binding`](bpy.types.XrActionMapBindings.html#bpy.types.XrActionMapBindings.new_from_binding "bpy.types.XrActionMapBindings.new_from_binding") | - [`XrActionMapBindings.remove`](bpy.types.XrActionMapBindings.html#bpy.types.XrActionMapBindings.remove "bpy.types.XrActionMapBindings.remove") - [`XrActionMapItem.bindings`](bpy.types.XrActionMapItem.html#bpy.types.XrActionMapItem.bindings "bpy.types.XrActionMapItem.bindings") - [`XrSessionState.action_binding_create`](bpy.types.XrSessionState.html#bpy.types.XrSessionState.action_binding_create "bpy.types.XrSessionState.action_binding_create") |
user: Provide the full official documentation entry for Light Groups, preserving all code examples.

assistant: Cycles only

A Light Group provides a limited *Combined* render pass where the scene is only illuminated by
certain lights. Multiple such passes can then be combined in compositing to construct a full render
with all the lights. The most straightforward way is to simply *Add* them together using
the [Mix Color Node](../../compositing/types/color/mix_color.xhtml), but by making more complex combinations,
it’s possible to change the color and intensity of individual lights without having to re-render.

To assign a Light object to a new or existing Light Group, use the panel
Object ‣ Shading ‣ Light Group ([details](../cycles/object_settings/object_data.xhtml#bpy-types-object-lightgroup)).

To assign the World background to a Light Group, use the panel
World ‣ Settings ‣ Light Group ([details](../cycles/world_settings.xhtml#bpy-types-world-lightgroup)).

Name
:   The name of the light group.

### Light Group Sync

These operators are available from the  button to the right of the
Light Group list.

Add Used Lightgroups
:   Create Light Groups for any lights that reference a non-existing one.

Remove Unused Lightgroups
:   Delete any Light Groups that are not referenced by any lights.
user: Give a detailed overview of Visualization: syntax, arguments, return values, common patterns.

assistant: In Object Mode, the calculated mesh is shown, along with a black “selection ring”.

[[image reference removed]](../../_images/modeling_metas_introduction_influence-selection.png)

Meta Ball in Edit Mode.

In Edit Mode (Fig. [Meta Ball in Edit Mode.](#fig-meta-ball-example)), a meta is displayed as a mesh
(either shaded or as black wireframe, but without any vertex of course),
with two colored circles: a red one for selection (pink when selected),
and a green one for a direct control of the meta’s stiffness (light green when active).
Note that except for the [scale transformation](../../scene_layout/object/editing/transform/scale.html#bpy-ops-transform-resize),
having the green circle highlighted is equivalent to having the red one.
user: Describe ShaderNodeOutputWorld(ShaderNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # ShaderNodeOutputWorld(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.ShaderNodeOutputWorld(*ShaderNode*)
:   Output light color information to the scene’s World

    is_active_output
    :   True if this node is used as the active output

        Type:
        :   boolean, default False

    target
    :   Which renderer and viewport shading types to use the shaders for

        - `ALL`
          All – Use shaders for all renderers and viewports, unless there exists a more specific output.
        - `EEVEE`
          EEVEE – Use shaders for EEVEE renderer.
        - `CYCLES`
          Cycles – Use shaders for Cycles renderer.

        Type:
        :   enum in [`'ALL'`, `'EEVEE'`, `'CYCLES'`], default `'ALL'`

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

assistant: When linking a rig into another file, you generally want to create a collection that includes
the generated rig and the character mesh. You do not need to include the meta-rig or the widget
object collection. You then link in the collection and run
[Make Library Override](../../../files/linked_libraries/library_overrides.xhtml#bpy-ops-object-make-override-library).

The `rig_ui_template.py` text data-block responsible for the rig UI
will be automatically linked along with the rig, you don’t need to link it separately.
However, the script will not run until you run it manually from the Text editor or save and restart Blender.
user: What is Basic and how is it used in Blender Python scripting?

assistant: # Basic

These rig types are used to generate simple single-bone features,
and for custom rigging done directly in the meta-rig.

The single-bone rig types must be applied separately to every bone even within a connected chain,
and can have connected children controlled by a different rig type.
This is unlike chain-based rig types that usually consume the whole connected chain.
user: Explain Is Face Smooth Node in complete detail according to the official Blender documentation.

assistant: # Is Face Smooth Node

[image reference removed]

The *Is Face Smooth* node outputs true for each face of the mesh if that face
is marked to render smooth shaded. Otherwise, if the face is marked to render as flat
shaded, then the node outputs false.
user: What is Light Type Items and how is it used in Blender Python scripting?

assistant: # Light Type Items

POINT:
:   Point.

    Omnidirectional point light source.

SUN:
:   Sun.

    Constant direction parallel ray light source.

SPOT:
:   Spot.

    Directional cone light source.

AREA:
:   Area.

    Directional area light source.
user: Describe Tool Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: Threshold
:   How much changes in color affect the mask generation. A smaller threshold includes fewer similar colors.
    A larger threshold includes much more similar colors.

Contiguous
:   Mask only contiguous color areas. Colors that don’t touch the one that you click on will not be masked.

Invert
:   Invert the generated mask.

Preserve Previous Mask
:   Preserve previous mask and add or subtract the new one generated by the colors.
user: Provide the full official documentation entry for Visual Geometry to Objects, preserving all code examples.

assistant: Creates new objects from the evaluated geometry of the active object,
including the effects of all modifiers, constraints, and instancing.

This operator is similar to [Make Instances Real](#bpy-ops-object-duplicates-make-real),
but with several key differences:

- Instanced geometry is **not** realized. Instead, shared data is preserved between objects that use it.
- The original object is **not removed or modified**,
  avoiding unintended disruptions to relationships with other objects.
- Instancing hierarchies are preserved by creating new objects
  and collections that reflect the evaluated structure.

This operator is useful for extracting visible results of geometry nodes, modifiers, or instancing setups
without permanently modifying the original scene structure.
user: Explain What is an Add-on? in complete detail according to the official Blender documentation.

assistant: An add-on is simply a Python module with some additional requirements so Blender
can display it in a list with useful information.

To give an example, here is the simplest possible add-on:

```
bl_info = {
    "name": "My Test Add-on",
    "blender": (2, 80, 0),
    "category": "Object",
}
def register():
    print("Hello World")
def unregister():
    print("Goodbye World")
```

`bl_info`
:   is a dictionary containing add-on metadata such as the title,
    version and author to be displayed in the Preferences add-on list.
    It also specifies the minimum Blender version required to run the script;
    older versions won’t display the add-on in the list.

`register`
:   is a function which only runs when enabling the add-on,
    this means the module can be loaded without activating the add-on.

`unregister`
:   is a function to unload anything setup by `register`,
    this is called when the add-on is disabled.

Notice this add-on does not do anything related to Blender
(the `blender_api:bpy` module is not imported for example).

This is a contrived example of an add-on that serves to illustrate the point
that the base requirements of an add-on are simple.

An add-on will typically register operators, panels, menu items, etc,
but it’s worth noting that *any* script can do this,
when executed from the Text editor or even the interactive console –
there is nothing inherently different about an add-on that allows it to integrate with Blender,
such functionality is just provided by the `blender_api:bpy` module for any script to access.

So an add-on is just a way to encapsulate a Python module in a way a user can easily utilize.
user: How do I use Components in Blender? Include parameters, examples, warnings and best practices.

assistant: Materials consist of three shaders, defining the appearance of the surface,
the volume inside the object, and the displacement of the surface.

[image reference removed]

### Surface Shader

The [surface shader](components/surface.xhtml) controls the textures
and light interaction at the surface of the mesh.

### Volume Shader

The [volume shader](components/volume.xhtml) defines the interior of the mesh.
A material can have just a volume shader for cases like smoke and fire,
or it can be combined with a surface shader for materials like cloudy glass.

### Displacement

The shape of the surface and the volume inside it may be altered by
[displacement](components/displacement.xhtml).
This way, textures can then be used to make the mesh surface more detailed.

Depending on the settings, the displacement may be virtual,
only modifying the surface normals to give the impression of displacement,
which is known as bump mapping, or a combination of real and virtual displacement.
user: How do I use Visibility Control in Blender? Include parameters, examples, warnings and best practices.

assistant: Parts of the mesh can be hidden in Sculpt Mode.
Because hidden faces cannot be sculpted, hiding makes it easier to isolate what you want to work on.
Hiding geometry also improves the viewport performance.

Hiding is shared between all modes, except Object Mode
(i.e. hiding/showing of faces in one mode will hide the same faces in other modes too).

Unlike [Selection Masking](../../selection_visibility.html) in other painting modes,
Sculpt Mode primarily uses Masks and Face Sets to easily control the mesh visibility
and which faces can currently be edited.
The exception is the [Clipping Region](../../selection_visibility.html#clipping-region), which can be used in any mode.

The most common shortcuts are `H` to hide the face set under the cursor
and `Shift`-`H` to isolate the face set under the cursor (or show everything).

[Inverting the visibility](../editing/sculpt.html#bpy-ops-sculpt-face-set-change-visibility)
and [showing all](../editing/sculpt.html#bpy-ops-paint-hide-show-all) is also available in the `Alt`-`W` pie menu.

Modifying visibility can also be done via the [Hide Gesture Tools](../tools/hide_tools.html).
user: Provide the full official documentation entry for World Environment, preserving all code examples.

assistant: # World Environment

[image reference removed]

Lighting with an HDR image.

The world defines the environment that the scene is in.
The surface shader sets the background and environment lighting,
either as a fixed color, sky model or HDRI texture.
With volume shaders the entire scene can be covered in mist or other volumetric effects.
user: Provide the full official documentation entry for Levels, preserving all code examples.

assistant: Adds an offset and a scale to all weights of the selected weight groups.
with this tool you can raise or lower the overall “heat” of the weight group.

[image reference removed]

Levels example.

Subset
:   Restrict the tool to a subset.
    See above [The Subset Option](#sculpt-paint-weight-paint-editing-subset) for how subsets are defined.

Offset
:   A value from the range (-1.0 - 1.0) to be added to all weights in the vertex group.

Gain
:   All weights in the Subset are multiplied with the gain.
user: Show practical ways to work with Torso Bones in a Blender add-on or script – include code.

assistant: Start by identifying on your character basic torso zones to follow as guide for bones placement.

Head, chest and pelvis are rigid zones, so they require less bones.
Having a good edge loop placement around zone boundaries on your model
will help in having correct deformation after armature binding.

[image reference removed]

Torso Landmarks.

Starting from the side view, place the main spine bones trying to use
one bone for the rigid areas and two for the flexible ones.
In addition to the main spine, the torso is provided with additional pelvis bones (to oppose the leg bending),
two breast controls and two shoulder bones.

Even if the pelvis bones will not appear in the final rig as controls, they will contribute to deformation.

[image reference removed]

Torso Bones Positioning.
user: Explain Download Blender in complete detail according to the official Blender documentation.

assistant: Blender offers a variety of different binary packages to choose from depending on their level of stability. Each
package has the trade off of newest features versus stability. The package that is right for you depends on your
requirements for those two. A studio, for example, might want to have *long-term support*, while a hobbyist may want
newer features, while others may just want to test upcoming features. Each package described below has something just
right for everyone.

[Stable Release](https://www.blender.org/download/)
:   A package that contains the latest features and is considered stable without regressions. A new stable version is
    available roughly every three months.

[Long-term Support](https://www.blender.org/download/lts/)
:   A package designed for long-lasting projects requiring a very stable version of Blender. LTS releases are supported for two years and will not have any new features, API changes or
    improvements. A new long-term support version is available every year. *These LTS releases will occasionally have
    minor patches (such as 4.2.6) which improve stability or fix critical bugs.*

[Daily Builds](https://builder.blender.org/download/)
:   A package updated daily to include the newest changes in development. These versions are automatically built on a
    schedule. They are not as thoroughly tested as the release types above, and might break or crash. Builds marked as
    **Alpha** are still undergoing major changes and feature additions, while those marked **Beta** are
    feature-complete and are under development for refinement and stability.

    Stability can be expected to increase from Alpha to Beta to Release Candidate (RC) to a final release.

[Build from Source](https://developer.blender.org/docs/handbook/building_blender/)
:   Blender’s source code is available for free to either reference or to build and use. While normal users are
    **not** expected to compile Blender, it does have advantages:

    - Blender is always up to date.
    - It allows access to any version or branch where a feature is being developed.
    - It can be freely customized.
    - Curious users can look through the source code and make small changes to see the effects to better understand how
      Blender works.

The procedure for installing a binary, either the latest stable release or a daily build, is the same. Follow the
steps for your platform listed below.
user: Show practical ways to work with Known Issues in a Blender add-on or script – include code.

assistant: ### Dense Meshes

Selecting dense meshes with X-Ray disabled, has a limitation where dense meshes may not have
all the elements selected.
When selecting regions with Box, Circle and Lasso select, vertices may overlap each other causing
some vertices not to be selected.
This is a limitation with the current selection method, you may workaround this by zooming in or enabling X-Ray.

### N-Gons in Face Select Mode

[image reference removed]

N-gon face having its center dot inside another face.

As already noted, in X-Ray and Wireframe mode faces are marked with a dot in the middle.
With n-gons that can lead in certain cases to a confusing display.
The example shows the center dot of the U-shaped n-gon being inside of the oblong face inside the “U”.
It is not easy to identify which dot belongs to which face (the orange dot in the image is the object origin).
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Curl
:   A vector grid representing the curl (local rotation) of the input field.
    The direction of the output vectors indicates the axis of rotation,
    and their magnitude represents the rotational strength at each voxel.
user: Provide the full official documentation entry for ParticleSettingsTextureSlots(bpy_struct), preserving all code examples.

assistant: # ParticleSettingsTextureSlots(bpy_struct)

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

*class* bpy.types.ParticleSettingsTextureSlots(*bpy_struct*)
:   Collection of texture slots

    *classmethod* add()
    :   add

        Returns:
        :   The newly initialized mtex

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

    *classmethod* create(*index*)
    :   create

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

        Returns:
        :   The newly initialized mtex

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

    *classmethod* clear(*index*)
    :   clear

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

    *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 Adjustments in a Blender add-on or script – include code.

assistant: [image reference removed]

Layers adjustment panel.

Tint Color
:   Color that tint any material colors used in the layer.

Factor
:   Controls the amount of tint color to apply.

Stroke Thickness
:   Thickness value that override the strokes thickness in the layer.
user: Provide the full official documentation entry for Tune Image Node, preserving all code examples.

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

assistant: # PaintCurve(ID)

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type