PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Collections and Dynamic Linking from the Blender manual or Python API, including usage steps and snippets.

assistant: See [Appending and Linking](../../../../files/linked_libraries/index.xhtml)
to understand how to dynamically link data from another blend-file into the current file.
You can dynamically link collections from one blend-file to another.
When you do so, the linked collection does not appear anywhere in your scene
until you create an object controlling where the collection instance appears.
user: Explain Boids in complete detail according to the official Blender documentation.

assistant: # Boids

[image reference removed]

Boid Physics settings.

Boids particle systems are controlled by a limited artificial intelligence,
which can be programmed to follow basic rules and behaviors.
They are ideal for simulating flocks, swarms, herds and schools of various kind of animals,
insects and fishes or predators vs. preys simulations.
They can react on the presence of other objects and on the members of their own system.
Boids can handle only a certain amount of information,
therefore the sequence of the *Boid Brain* rules is very important.
In certain situations only the first three parameter are evaluated.
user: Explain ShaderNodeFresnel(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeFresnel(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.ShaderNodeFresnel(*ShaderNode*)
:   Produce a blending factor depending on the angle between the surface normal and the view direction using Fresnel equations.
    Typically used for mixing reflections at grazing angles

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for spines.super_spine, preserving all code examples.

assistant: Will create a complete bendy and stretchy b-bones spine system based on bone numbers of
your bone chain and user defined options.

This is a composite wrapper of [spines.basic_spine](#spines-basic-spine), [spines.super_head](#spines-super-head) and [spines.basic_tail](#spines-basic-tail).
Note that for the tail, the direction of the bones is reversed compared to the separate rig.

Requirement: A chain of at least three connected bones (base system).

[image reference removed]

Spine required bones.

Pivot Position (integer)
:   Defines the pivot position for torso and hips.

Head (Boolean)
:   When checked neck and head systems will be added to your spine rig.

    Neck Position (integer)
    :   Defines the bone where the neck system starts. The last bone will always be the head system.
        If neck position is the last bone of the chain, then only the head system will be created ignoring the neck.

Tail (Boolean)
:   When checked tail system will be added to your spine rig.

    Tail Position (integer)
    :   Defines the bone where the tail system starts. The next bone will always be the hips system.

X, Y, Z (Boolean)
:   When generating a tail, specifies which local axis rotations should be replicated along the chain.

Assign Tweak Layers
:   If enabled, allows placing the Tweak controls in different bone collections from the IK bones.

[image reference removed]

Spine default bones.

[image reference removed]

Spine with tail bones.
user: Provide the full official documentation entry for Introduction, preserving all code examples.

assistant: # Introduction

The first step is to unwrap your mesh. Generally, it is recommended to start unwrapping
when only minor adjustments to the geometry of your model are required.
If you do add faces or subdivide existing faces when a model is already unwrapped,
Blender will add those new faces for you,
but you may need to do additional mapping or editing. In this fashion,
you can use the UV texture image to guide additional geometry changes.
user: Show practical ways to work with Index in a Blender add-on or script – include code.

assistant: # Index

[**_**](genindex-_.html)
| [**A**](genindex-A.html)
| [**B**](genindex-B.html)
| [**C**](genindex-C.html)
| [**D**](genindex-D.html)
| [**E**](genindex-E.html)
| [**F**](genindex-F.html)
| [**G**](genindex-G.html)
| [**H**](genindex-H.html)
| [**I**](genindex-I.html)
| [**J**](genindex-J.html)
| [**K**](genindex-K.html)
| [**L**](genindex-L.html)
| [**M**](genindex-M.html)
| [**N**](genindex-N.html)
| [**O**](genindex-O.html)
| [**P**](genindex-P.html)
| [**Q**](genindex-Q.html)
| [**R**](genindex-R.html)
| [**S**](genindex-S.html)
| [**T**](genindex-T.html)
| [**U**](genindex-U.html)
| [**V**](genindex-V.html)
| [**W**](genindex-W.html)
| [**X**](genindex-X.html)
| [**Y**](genindex-Y.html)
| [**Z**](genindex-Z.html)

[**Full index on one page**
(can be huge)](genindex-all.html)
user: Describe Curve to Mesh Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Curve to Mesh Node

[image reference removed]

The Curve to Mesh node converts all splines of a curve to a mesh.
Optionally, a profile curve can be provided to give the curve a custom shape.

The node transfers attributes to the result. Attributes that are built-in on meshes but not curves,
like `sharp_face`, will be transferred to the correct domain as well.
user: What is ThemeTextEditor(bpy_struct) and how is it used in Blender Python scripting?

assistant: # ThemeTextEditor(bpy_struct)

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

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

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

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

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

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

    space
    :   Settings for space

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

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

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`Image.tiles`](bpy.types.Image.html#bpy.types.Image.tiles "bpy.types.Image.tiles") - [`UDIMTiles.active`](bpy.types.UDIMTiles.html#bpy.types.UDIMTiles.active "bpy.types.UDIMTiles.active") - [`UDIMTiles.get`](bpy.types.UDIMTiles.html#bpy.types.UDIMTiles.get "bpy.types.UDIMTiles.get") | - [`UDIMTiles.new`](bpy.types.UDIMTiles.html#bpy.types.UDIMTiles.new "bpy.types.UDIMTiles.new") - [`UDIMTiles.remove`](bpy.types.UDIMTiles.html#bpy.types.UDIMTiles.remove "bpy.types.UDIMTiles.remove") |
user: Explain Keyframe Paste Merge Items in complete detail according to the official Blender documentation.

assistant: # Keyframe Paste Merge Items

MIX:
:   Mix.

    Overlay existing with new keys.

OVER_ALL:
:   Overwrite All.

    Replace all keys.

OVER_RANGE:
:   Overwrite Range.

    Overwrite keys in pasted range.

OVER_RANGE_ALL:
:   Overwrite Entire Range.

    Overwrite keys in pasted range, using the range of all copied keys.
user: What is Interaction in Real-Time and how is it used in Blender Python scripting?

assistant: To work with a soft body simulation, you will find it handy to use the Timeline editor.
You can change between frames and the simulation will always be shown in the actual state.
You can interact in real-time with the simulation,
e.g. by moving collision objects or shaking a soft body object.

You can then select the soft body object while running the simulation and *Apply*
the modifier in the *Modifiers* tab of the Properties.
This makes the deformation permanent.
user: Provide the full official documentation entry for Minimize Stretch, preserving all code examples.

assistant: The *Minimize Stretch* tool, reduces UV stretch by minimizing the difference between
the angles in 3D and the angles in UV space.
This operation is similar to the [Relax](tools/relax.xhtml)
tool with the *Geometry* *Method*, but uses a different algorithm.

Fill Holes
:   Just during *minimize stretch*, internal holes will be filled with temporary polygons
    to prevent stretching and overlaps of the surrounding UVs.

Blend
:   The fraction between 0 and 1 of the original UVs to blend in once the stretch is minimized.
    A blend of 0 is the fully minimized stretch. Blend of 0.5 is halfway between the original UVs
    and the minimize stretch UVs.

Iterations
:   More iterations result in smoother UVs, but take longer to process.
user: What is Outputs and how is it used in Blender Python scripting?

assistant: Grid
:   The resulting grid with all active tiles converted into individual voxels.

    For fog volumes, this means that interior sparse tiles are expanded into
    voxels with individually adjustable values. For SDF grids, this produces a
    fully dense voxel representation suitable for precise sampling and editing.
user: How do I use Numeric Input in Blender? Include parameters, examples, warnings and best practices.

assistant: # Numeric Input

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

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

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

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

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

[image reference removed]

Numeric input displayed in the footer.
user: Show practical ways to work with Displays in a Blender add-on or script – include code.

assistant: The color space of the display that images and video are being created for.

Regular compute displays support sRGB, and most images and videos are
stored in this color space. However moderns displays often support a wider
gamut and high dynamic range content.

Standard Dynamic Range (SDR)
:   sRGB:
    :   Basic display supported everywhere.

    Display P3:
    :   Wide gamut for Apple devices and other modern displays.

    Rec.1886:
    :   Used by many older TVs.

    Rec.2020:
    :   Even wider gamut than P3 supported by some displays.

High Dynamic Range (HDR)
:   Rec.2100 PQ:
    :   For HDR displays with Rec.2020 wide gamut, up to 10000 nits.

    Rec.2100 HLG:
    :   For HDR TVs with Rec.2020 wide gamut, up to 1000 nits.

### Wide Gamut

Select the “Display P3” or “Rec.2020” display to view wide gamut colors.

This should be used in conjunction with the “ACEScg” or “Linear Rec.2020” working space
for materials, lights, rendering and compositing.

Requirements:

- A P3 or Rec.2020 capable monitor.
- macOS: Any Apple Silicon device.
- Linux: Use Wayland, and set the Vulkan backend in the Blender system preferences.
- Windows: Enable “Automatically manage color for apps” in the Windows display settings,
  and set the Vulkan backend in the Blender system preferences.

### High Dynamic Range

Select the “Rec.2100 PQ” or “Rec.21000 HLG” display to view high dynamic range (HDR) colors.

With standard dynamic range (SDR), views must significantly lower bright colors to fit within the range.
With high dynamic range it is possible to go beyond and more accurately display the scene. HDR displays have limits
too, and there are separate views for 500, 1000, 2000 and 4000 nits to target displays with different maximum
luminance.

In Blender, HDR content automatically scales up and down along with display brightness. Seeing the full range often
requires lowering the display brightness, to make enough headroom above SDR white.

Requirements:

- A HDR capable monitor.
- macOS: Any Apple Silicon device.
- Linux: Use Wayland, and set the Vulkan backend in the Blender system preferences.
- Windows: Enable “Use HDR” in the Windows display settings, and set the Vulkan backend in the Blender system
  preferences.

### Display Emulation

Automatic:
:   Display images consistent with most other applications, to preview images and video
    for export. A best effort is made to emulate the chosen display on the actual
    display device.

Off:
:   Directly output image as produced by OpenColorIO. This is not correct in general,
    but may be used when the system configuration and actual display device is known
    to match the chosen display.

Emulation is not supported with older [OpenColorIO configurations](opencolorio.html#ocio-config).
user: What is Select Linked and how is it used in Blender Python scripting?

assistant: Selects all the bones in the chain which the active (last selected) bone belongs to.

All Forks
:   Selects all bones connected to the active bone even if the branch off from the current bone.

Linked bones selection.

|  |  |
| --- | --- |
| ../../../_images/animation_armatures_bones_selecting_single-bone.png   A single selected bone. | ../../../_images/animation_armatures_bones_selecting_whole-chain.png   Its whole chain selected with Linked. |
user: Give a detailed overview of GeometryNodeCustomGroup(GeometryNode): syntax, arguments, return values, common patterns.

assistant: # GeometryNodeCustomGroup(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.GeometryNodeCustomGroup(*GeometryNode*)
:   Custom Geometry Group Node for Python nodes

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

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

assistant: [image reference removed]

Brush Waves panel.

This panel is used to adjust brush influence to “Wave” surfaces.

Wave Type
:   Select what effect the brush creates in the wave simulation.

    Depth Change:
    :   The brush create waves when the intersection depth with the surface is *changed* on that point.
        If the brush is not moved, it will have no effect.

        Using a negative “Factor” with this type can create a nice looking “wake” for moving objects like ships.

    Obstacle:
    :   Constantly affects surface whenever intersecting.
        Waves are also reflected off this brush type.
        However, due the nature of wave simulation algorithm this type creates
        an unnatural “dent” in the surface if the brush is not moved.

    Force:
    :   Directly affects the velocity of wave motion.
        Therefore the effect is not one-to-one with brush intersection depth, yet the force strength depends on it.

    Reflect Only:
    :   This type has no visible effect on the surface alone but reflects waves that are already on the surface.

Factor
:   Adjusts how strongly brush “depth” affects the simulation.
    You can also use negative values to make brush pull water up instead of down.

Clamp Waves
:   In some cases the brush goes very deep inside the surface messing whole simulation up.
    You can use this setting to “limit” influence to only certain depth.
user: Describe Properties from the Blender manual or Python API, including usage steps and snippets.

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: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Mesh
:   Standard Mesh input.

Density
:   Value of voxels inside the generated fog volume.

Resolution Mode
:   How the voxel size is specified.

    Amount:
    :   Specify the approximate number of voxels along the diagonal.

    Size:
    :   Specify the voxel side length. It is recommended to be careful when tweaking this value,
        because small changes can have a large effect on the processing time.

Voxel Amount Amount
:   Specify the approximate number of voxels along the diagonal.

Voxel Size Size
:   Specify the voxel side length.

Interior Band Width
:   The maximum distance of the included voxels to the surface on the inside of the mesh.
user: What is Properties and how is it used in Blender Python scripting?

assistant: Distribution
:   Microfacet distribution to use.

    GGX:
    :   GGX microfacet distribution.

    Multiscatter GGX:
    :   Takes multiple scattering events between microfacets into account.
        This gives more energy conserving results, which would otherwise be visible as excessive darkening.

    Beckmann:
    :   Cycles Only
        Beckmann microfacet distribution.

Fresnel Type
:   Models for describing the metal’s appearance, by specifying the apparent color or the physical IOR.

    F82 Tint:
    :   Uses the [Adobe F82-Tint formula](https://helpx.adobe.com/content/dam/substance-3d/general-knowledge/asm/Adobe%20Standard%20Material%20-%20Technical%20Documentation%20-%20May2023.pdf)
        for the metallic fresnel. This allows for artist friendly control of the color near the edge of the
        material to simulate a complex IOR.

    Physical Conductor:
    :   Accepts Complex IOR measurements from real world metals to replicate a more accurate rendering
        of metals than the *F82 Tint* Fresnel type.

        Complex IOR values can be found from sources like the
        [Physically Based database for CG artists](https://physicallybased.info/)
        and [Refractive Index nk database](https://refractiveindex.info/).
user: Show practical ways to work with FunctionNodeBooleanMath(FunctionNode) in a Blender add-on or script – include code.

assistant: # FunctionNodeBooleanMath(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.FunctionNodeBooleanMath(*FunctionNode*)
:   Perform a logical operation on the given boolean inputs

    operation
    :   Type:
        :   enum in [Node Boolean Math Items](bpy_types_enum_items/node_boolean_math_items.html#rna-enum-node-boolean-math-items), default `'AND'`

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

assistant: # Best Practice

When writing your own scripts Python is great for new developers to pick up and become productive,
but you can also pick up bad practices or at least write scripts that are not easy for others to understand.
For your own work this is of course fine,
but if you want to collaborate with others or have your work included with Blender there are practices we encourage.
user: Give a detailed overview of CompositorNodeBilateralblur(CompositorNode): syntax, arguments, return values, common patterns.

assistant: # CompositorNodeBilateralblur(CompositorNode)

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

*class* bpy.types.CompositorNodeBilateralblur(*CompositorNode*)
:   Adaptively blur image, while retaining sharp edges

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

    update()

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain FunctionNodeSliceString(FunctionNode) in complete detail according to the official Blender documentation.

assistant: # FunctionNodeSliceString(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.FunctionNodeSliceString(*FunctionNode*)
:   Extract a string segment from a larger string

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Mask – Shadow Catcher
:   Enables the object to only receive shadow rays. It is to be noted that,
    shadow catcher objects will interact with other CG objects via indirect light interaction.
    This simplifies compositing CGI elements into real-world footage.

    [image reference removed]

    Example of the shadow catcher. Note how the material of the plane can still be viewed in the spheres.

### Ray Visibility

Objects can be set to be invisible to particular ray types.
This can be used, for example, to make an emitting mesh invisible to camera rays.
For instanced objects, visibility is inherited; if the parent object is hidden for some ray types,
the children will be hidden for these too.

In terms of performance, using these options is more efficient that using a shader node setup
that achieves the same effect.
Objects invisible to a certain ray will be skipped in ray traversal already,
leading to fewer ray casts and shader executions.

Camera
:   Makes the object visible to the [Camera](../../cameras.html);
    this includes the viewport’s perspective in viewport rendering.

Diffuse
:   Makes the object visible in diffuse rays.

Glossy
:   Makes the object visible in glossy rays.

Transmission
:   Makes the object visible in transmission rays.

Volume Scatter
:   Makes the object visible in volumetric scatter rays.

Shadow
:   Enables the object to cast shadows.

### Culling

In order to activate these options the respectively camera cull options have to be enabled
in the scene [simplify panel](../render_settings/simplify.html#render-cycles-settings-scene-simplify-culling).

Use Camera Cull
:   Ignore and this way make objects invisible to rays outside of the camera frustum.

Use Distance Cull
:   Will cull any objects further from the camera than a given distance. When used in combination with
    camera frustum culling, this can be used to avoid culling nearby objects that are outside the camera frustum,
    but still visible in reflections. It is also useful to cull small objects far from the camera.
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: The *Evaluate Closure* node is typically used to make a node group partially customizable while maintaining a stable,
reusable framework.

For example, a terrain generator might use *Evaluate Closure* to define how trees are distributed across a landscape:

1. Inside the generator group, replace the fixed tree placement logic with an *Evaluate Closure* node.
2. Expose the closure input on the group’s interface.
3. In the main node tree, connect a *Closure Zone* defining the desired tree distribution behavior.

Whenever the closure is evaluated, the connected node graph runs within the terrain generator’s context, producing a
customized result.

[image reference removed]

Example: custom tree distribution using *Evaluate Closure*.
user: How do I use Development in Blender? Include parameters, examples, warnings and best practices.

assistant: Only visible when [Developer Extras](interface.xhtml#bpy-types-preferencesview-show-developer-ui) are enabled.

I18n Branches
:   The path to the `/branches` directory of your local SVN translation copy, to allow translating from the UI.
user: Show practical ways to work with Tips in a Blender add-on or script – include code.

assistant: # Tips

As with all physics-enabled objects, pay close attention to the *Animated* checkbox
in the *Rigid Body* panel of the *Physics* tab in the Properties.
A common mistake is to use keyframe animation on a *Passive* physics
object without checking the *Animated* box. The object will move,
but the physics engine will behave as if the *Passive* is still in its starting place, leading to disappointment.
user: How do I use Options in Blender? Include parameters, examples, warnings and best practices.

assistant: Shape
:   The shape key to blend from.

Blend
:   Factor controlling how much of the shape is applied.

Add
:   If enabled, the blended offset is added on top of the current mesh positions.
    If disabled, the mesh is interpolated directly between its current shape and the chosen shape key.
user: Provide the full official documentation entry for Select Menu, preserving all code examples.

assistant: All `A`
:   Select all.

None `Alt`-`A`
:   Select none.

Invert `Ctrl`-`I`
:   Selects all the geometry that is not selected, and deselect currently selected components.

---

[Box Select](../../../interface/selecting.xhtml#tool-select-box) `B`
:   Interactive box selection.

[Circle Select](../../../interface/selecting.xhtml#tool-select-circle) `C`
:   Interactive circle selection.

[Lasso Select](../../../interface/selecting.xhtml#tool-select-lasso)
:   Interactive free-form selection.

---

Select Mirror `Shift`-`Ctrl`-`M`
:   Select mesh items at the mirrored location across the chosen axis.

[Select Random](random.xhtml#bpy-ops-mesh-select-random)
:   Selects a random group of vertices, edges, or faces, based on a percentage value.

[Checker Deselect](checker_deselect.xhtml#bpy-ops-mesh-select-nth)
:   Deselect alternate elements relative to the active item.

---

More/Less
:   More `Ctrl`-`NumpadPlus`
    :   Expands the selection to the adjacent elements of the selection type.

    Less `Ctrl`-`NumpadMinus`
    :   Contracts the selection from the adjacent elements of the selection type.

    Next Active `Shift`-`Ctrl`-`NumpadPlus`
    :   This uses selection history to select the next vertex, edge, or face based on surrounding topology.

    Previous Active `Shift`-`Ctrl`-`NumpadMinus`
    :   Select previous just removes the last selected element.

---

[Select Similar](similar.xhtml#bpy-ops-mesh-select-similar) `Shift`-`G`
:   Select elements similar to the current selection.

[Select All by Trait](all_by_trait.xhtml)
:   Select geometry by querying its characteristics.

Select Linked
:   [Select Linked](linked.xhtml#bpy-ops-mesh-select-linked)
    :   Selects all components that are connected to the current selection.

    [Shortest Path](linked.xhtml#bpy-ops-mesh-shortest-path-select)
    :   Path between two selected elements.

    Linked Flat Faces
    :   Select connected faces based on a threshold of the angle between them.
        This is useful for selecting faces that are planar.

Select Loops
:   [Edge Loops](loops.xhtml#bpy-ops-mesh-loop-multi-select)
    :   Select connected edges.

    [Face Loops](loops.xhtml#modeling-meshes-selecting-face-loops)
    :   Select connected faces.

    [Edge Rings](loops.xhtml#modeling-meshes-selecting-edge-rings)
    :   Select connected edge ring.

Sharp Edges
:   This tool selects all edges between two faces forming an angle greater than the angle value,
    where an increasing angle selects sharper edges.

Side of Active
:   Selects all vertices on the mesh in a single axis relative to the active vertex.
    In Vertex selection mode only.
user: Provide the full official documentation entry for NodeIndexSwitchItems(bpy_struct), preserving all code examples.

assistant: # NodeIndexSwitchItems(bpy_struct)

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

*class* bpy.types.NodeIndexSwitchItems(*bpy_struct*)
:   Collection of index_switch items

    new()
    :   Add an item at the end

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

        Parameters:
        :   **item** ([`IndexSwitchItem`](bpy.types.IndexSwitchItem.html#bpy.types.IndexSwitchItem "bpy.types.IndexSwitchItem"), (never None)) – Item, The item to remove

    clear()
    :   Remove all items

    move(*from_index*, *to_index*)
    :   Move an item to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the item to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the item

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

assistant: [image reference removed]

The Channels region.

This region is found on the left side of time-based editors like
the [Dope Sheet Editor](../../dope_sheet/introduction.xhtml) and the Graph Editor.
It shows a tree of items (objects, bones…) and their animated properties,
with the latter also being called “channels.” Each channel has an associated F-curve
describing how its value changes over time.

The rows are color-coded as follows:

- Dark blue: scenes, objects
- Light blue: [actions](../../../animation/actions.xhtml), [shape keys](../../../animation/shape_keys/index.xhtml) etc.
- Green: channel groups
- Gray: channels

Search `Ctrl`-`F`
:   Lets you filter the channels by typing a part of their name. Click the Invert button to instead
    show channels that *don’t* include the search text.

### Channels

The headers contain the following toggle buttons:

/ Pin
:   Keep the row and its children visible even when selecting a different object.

/ Hide
:   Hides the keyframes and curve associated with the channel.

/ Modifiers
:   Deactivates the modifiers of the curve.

/ Mute
:   Deactivates the curve, making the animation behave as though it doesn’t exist.

/ Lock `Tab`
:   Prevent the curve from being edited.

### Selection

- Select single header: click `LMB`
- Add/Remove single header to/from selection: click `Ctrl`-`LMB`
- Select range: click `Shift`-`LMB`
- Select All: `A`
- Deselect All: press `Alt`-`A` or double-tap `A`
- Box Select: drag `LMB`
- Box Add: drag `Shift`-`LMB`
- Box Remove: drag `Ctrl`-`LMB`
- Select all keyframes in the channel: double-click `LMB` on its header.

### Editing

- Rename (anything but a channel): double-click `LMB`
- Delete selected: `X` or `Delete`
- Lock selected: `Tab`

#### Sliders

[image reference removed]

The Action editor showing sliders.

If you enable View ‣ Show Sliders, the region will show a
value slider next to each channel. Changing such a slider will change the value
of the curve at the current frame, creating a keyframe if one doesn’t already exist.
user: Describe Draw from the Blender manual or Python API, including usage steps and snippets.

assistant: # Draw

Moves vertices inward or outward, based the average vertex normals within the brush radius.
This is a very default behavior for sculpting and can be used in most cases.

It is common to use this particular brush with heavy customization for creating many custom brushes.
user: Explain Mask in complete detail according to the official Blender documentation.

assistant: # Mask

This page details the mask related shortcut operators and menu operators in sculpt mode.
Other related information to masks can also be found at the bottom of the page.

Masks can be edited across all visible faces.
Using `A` opens a pie menu to choose the most common operations.
user: Describe Basic Handler Example from the Blender manual or Python API, including usage steps and snippets.

assistant: This script shows the most simple example of adding a handler.

```
import bpy

def my_handler(scene):
    print("Frame Change", scene.frame_current)

bpy.app.handlers.frame_change_pre.append(my_handler)
```
user: How do I use Collections in Blender? Include parameters, examples, warnings and best practices.

assistant: # Collections

There can be many objects in a scene: A typical stage scene consists of furniture, props,
lights, and backdrops.
Blender helps you keep everything organized by allowing you to group like objects together.
Objects can be grouped together without any kind of transformation relationship (unlike parenting).
Collections are used to just logically organize your scene,
or to facilitate one-step appending or linking between files or across scenes.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Vector
:   Texture coordinate to sample texture at;
    defaults to Generated texture coordinates if the socket is left unconnected.

Scale
:   Scale of the texture.

Distortion
:   Amount of distortion.
user: What is Light Output Node and how is it used in Blender Python scripting?

assistant: # Light Output Node

[image reference removed]

The *Light Output* node is used customize a [Light object](../../lights/light_object.xhtml).
Currently only supported for Cycles.

To start using this node, select the Light and click Nodes ‣ Use Nodes
in the *Data* tab of the [Properties Editor](../../../editors/properties_editor.xhtml) editor.
user: What is Flip Names and how is it used in Blender Python scripting?

assistant: You can flip left/right markers (see above) in selected bone names.
This can be useful if you have constructed half of a symmetrical rig
(marked for a left or right side) and duplicated and mirrored it,
and want to update the names for the new side.
Blender will swap text in bone names according to the above naming conventions,
and remove number extensions if possible.
user: Give a detailed overview of Set User Region: syntax, arguments, return values, common patterns.

assistant: Defines a rectangular region in the UV Editor to be used as a *Custom Region*

Once defined, this region can be selected as the *Pack To* target in the *Pack Islands* operator
by choosing **Custom Region** and enabling [Custom Region](#bpy-types-toolsettings-use-uv-custom-region).
user: Describe NodeTreeInterfaceSocketShader(NodeTreeInterfaceSocket) from the Blender manual or Python API, including usage steps and snippets.

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

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

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

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

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

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: |  |  |
| --- | --- |
| - [`CacheFile.layers`](bpy.types.CacheFile.html#bpy.types.CacheFile.layers "bpy.types.CacheFile.layers") - [`CacheFileLayers.active`](bpy.types.CacheFileLayers.html#bpy.types.CacheFileLayers.active "bpy.types.CacheFileLayers.active") | - [`CacheFileLayers.new`](bpy.types.CacheFileLayers.html#bpy.types.CacheFileLayers.new "bpy.types.CacheFileLayers.new") - [`CacheFileLayers.remove`](bpy.types.CacheFileLayers.html#bpy.types.CacheFileLayers.remove "bpy.types.CacheFileLayers.remove") |