PGCRYPT/OpenBlender_Train huggingface dataset:
user: How do I use CompositorNodeRGBToBW(CompositorNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # CompositorNodeRGBToBW(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.CompositorNodeRGBToBW(*CompositorNode*)
:   Convert RGB input into grayscale using luminance

    *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: What is Index of Nearest and how is it used in Blender Python scripting?

assistant: # Index of Nearest

[image reference removed]

The **Index of Nearest** node is a way to find other close elements in the same geometry.
If needed you can use Group ID to determine the group of neighbors to be analyzed together.

This is an alternative to the [Sample Nearest Node](sample_nearest.xhtml) node.
The main difference is that this node does not require a geometry input, because the geometry
from the [field context](../../fields.xhtml#field-context) is used.
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Mode
:   Vertices:
    :   Attaches a new freestanding edge to each selected vertex.

    Edges:
    :   Attaches a new quad face to each selected edges. Vertices shared by the
        original selected edges are also shared in the duplicated edges.

    Faces:
    :   Extrudes contiguous regions of selected faces, or each selected face individually,
        depending on the *Individual* boolean input.

        When the *Individual* input is false, the node will find regions of connected faces and generate
        new “side” faces on the boundaries of those regions. Any vertices, edges or faces on the *inside*
        of the regions simply are moved, not duplicated. If the whole mesh is selected and it is already
        a [Manifold](../../../../glossary/index.xhtml#term-Manifold) shape, then the result will just be that the whole mesh gets resized.
user: Show practical ways to work with Animating with Grease Pencil in a Blender add-on or script – include code.

assistant: The main goal of Grease Pencil is to offer a 2D animation tool full immersed in a 3D environment.

[image reference removed]

Sample animation showing Grease Pencil object keyframes in the Dope Sheet with onion skinning enabled.

In Blender, Grease Pencil objects can be animated in many ways:

Moving as a whole object
:   Changing their position, orientation or size in time;

Drawing frame by frame
:   Drawing one frame at a time (traditional animation).

Deforming them
:   Animating their points;

Inherited animation
:   Causing the object to move based on the movement of another object
    (e.g. its parent, hook, armature, etc.). Useful for cut-out animation for example.

For a complete overview of animation in Blender please refer to
the [Animation & Rigging](../../animation/index.xhtml) chapter.
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: - A single colored texture (0.5, 0.0, 0.5) creates a force in the direction of the positive Y axis,
  e.g. hair is orientated to the Y axis.
- A blend texture with color ramp can be used to created a force “plane”. E.g. on the left side (0.5, 0.5, 0.5),
  on the right side (1.0, 0.5, 0.5) you have a force plane perpendicular to XY (i.e. parallel to Z).
  If you use an object for the coordinates, you can use the object to push particles around.
- An animated wood texture can be used to create a wave like motion.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Color
:   Scattering coefficients per color channel.

Density
:   The density of the scatter effect.

Anisotropy Henyey-Greenstein Draine
:   Controls the relative amount of backward and forward scattering.

IOR Fournier-Forand
:   Refractive index of the scattering particles relative to water. Common ocean waters range between
    1.0 and 1.2, while turbid waters with higher density of particles have higher IORs.

Backscatter Fournier-Forand
:   Fraction of light that is scattered backwards. Most oceanic particles have backscatter
    values between 0.001 (e.g., very large phytoplankton) and 0.1 (e.g., very small mineral particles),
    pure water has a backscatter of 0.5. Values taken from
    [Ocean Optics Web Book](https://www.oceanopticsbook.info/view/scattering/the-fournier-forand-phase-function).

Alpha Draine
:   Blending factor between Henyey-Greenstein (\(\alpha = 0\))
    and Cornette & Shanks (\(\alpha = 1\)) phase functions.

Diameter Mie
:   Diameter of the scattering particles in µm.
user: Show practical ways to work with SDF Grid Mean Node in a Blender add-on or script – include code.

assistant: # SDF Grid Mean Node

[image reference removed]

The *SDF Grid Mean* node applies mean (box) filter smoothing to amSigned Distance Field (SDF) grid.
This operation averages voxel values within a local neighborhood to smooth
out small variations and noise while preserving the overall shape of the field.

The filter works as a fast, separable averaging operation—sometimes called a
*box filter*—and is well suited for general-purpose smoothing or softening of
SDF data after boolean, voxelization, or other volumetric operations.
user: Explain Textures in complete detail according to the official Blender documentation.

assistant: Blender has various built in procedural texture nodes,
with texture coordinates and various parameters as input, and a color or value as output.
No texture data-blocks are needed; instead node groups can be used for reusing texture setups.

For UV mapping and texture painting in the 3D Viewport, the Image Texture node must be used.
When setting such a node as active, it will be displayed in the 3D Viewport
while using [Texture color](../workbench/color.html) mode.
This method can be used to preview painted textures while texture painting.

The default texture coordinates for all nodes are Generated coordinates,
except for Image textures that use UV coordinates by default.
Each node includes some options to modify the texture mapping and resulting color,
and these can be edited in the texture properties.
user: Explain References in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`TextCurve.body_format`](bpy.types.TextCurve.html#bpy.types.TextCurve.body_format "bpy.types.TextCurve.body_format") | - [`TextCurve.edit_format`](bpy.types.TextCurve.html#bpy.types.TextCurve.edit_format "bpy.types.TextCurve.edit_format") |
user: What is Header and how is it used in Blender Python scripting?

assistant: The *Header* contains various menus, buttons and options, partially based on the current node tree type.

[image reference removed]

Common node editor header options.

View
:   This menu changes your view of the editor.

Select
:   This menu allows you to select a node or groups of nodes.

Add
:   This menu allows you to add nodes.

Node
:   This menu allows you to do things with selected nodes.

Pinned
:   When enabled, the editor always displays the currently selected node tree,
    regardless of changes in the active object or scene.
    This allows you to edit a material, texture, or compositor node tree independently
    of what is selected in the 3D Viewport or which scene is active.
    Useful when working across multiple objects or scenes but wanting to keep the editor
    focused on one specific node tree.

Parent Node Tree
:   Leaves the current [node group](groups.html) and returns to the parent node group/tree.

Snapping
:   Change options for snapping node positions to achieve a cleaner node tree layout.
    See [Arranging Nodes](arranging.html).
user: Provide the full official documentation entry for Color Palette, preserving all code examples.

assistant: Color Palettes are a way of storing a brush’s color so that it can be used at a later time.
This is useful when working with several colors at once.

Palette
:   A [Data-Block Menu](../../interface/controls/templates/data_block.xhtml#ui-data-block) to select a palette.

(New Pallet Color)
:   Adds the current brush’s primary *Color* to the palette.

(Delete Pallet Color)
:   Removes the currently selected color from the palette.

/ (Move Pallet Color)
:   Moves the selected color up/down one position.

(Sort By)
:   Sort Colors by Hue, Saturation, Value, Luminance.

Color List
:   Each color that belongs to the palette is presented in a list.
    Clicking on a color will change the brush’s primary *Color* to that color.
user: What is Dyntopo and how is it used in Blender Python scripting?

assistant: Dynamic topology (aka Dyntopo) is a dynamic tessellation
sculpting method that automatically adds and removes topology under the brush.

[image reference removed]

Unlike the Voxel Remesher, this makes it possible to sculpt complex shapes
without thinking about the resolution or topology.
It also allows to define a different resolution wherever necessary.
Much more complex base mesh sculpting is especially useful with this technique.

The disadvantages of this technique are a slower performance and limited support for some sculpt mode features.
Custom attributes like Color Attributes, UV Maps and Face Sets are also lost or corrupted when using Dyntopo.

This feature shares the same shortcuts with voxel remeshing when enabled.
Use `R` to define the resolution and `Ctrl`-`R` to flood fill the resolution (if Constant Detail is used).

[image reference removed]

Brushes like [Density](../brushes/simplify.html),
[Snake Hook](../brushes/snake_hook.html)
and [Clay Strips](../brushes/clay_strips.html) work especially well with this feature.
user: Explain Stretch To Constraint in complete detail according to the official Blender documentation.

assistant: # Stretch To Constraint

The *Stretch To* constraint makes an object or bone point at, and scale towards,
a target. Unlike the other “track” constraints, it can only do this using the local Y axis,
making it mainly useful for bones.

The constraint can also perform “volume preservation,” making the owner thinner when the
target moves away and thicker when it comes closer. This is useful for stretching
and squashing of stylized characters, for example. However, because it simply
adjusts the X and Z scales according to the Y scale, it works for any type of object,
not just meshes.
user: Explain GeometryNodeToolSelection(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeToolSelection(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.GeometryNodeToolSelection(*GeometryNode*)
:   User selection of the edited geometry, for tool execution

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

assistant: # Shrinkwrap Constraint

The *Shrinkwrap* constraint snaps an object or bone to the surface of a mesh. It’s similar
to the [Shrinkwrap Modifier](../../../modeling/modifiers/deform/shrinkwrap.html), which snaps every vertex of a mesh to
the surface of another.

Like other constraints, the *Shrinkwrap* constraint ignores the geometry of its owner object
and purely works with its [origin](../../../scene_layout/object/origin.html). This means that, if the
origin is at the object’s center, the object will clip into the target mesh instead of sitting
on its surface. This can be mitigated with the *Distance* setting.
user: Provide the full official documentation entry for Generating the Set of Files for the Target Language, preserving all code examples.

assistant: 1. Check out the current translation repository using the command:

   ```
   git clone https://projects.blender.org/blender/blender-manual-translations.git locale
   ```

   This will download all language sets available in the repository into the `locale` directory of your drive. You
   can go to the `locale` directory to see the hidden subdirectory `.git` within it, together with directories of
   languages. You’ll need to add your own set of files for the language you are trying to translating to.
2. From the `blender-manual` directory to generate a set of files for `fr` language:

   ```
   make update_po
   ```

   These files are still in English only, with all `msgstr` entries blank.
3. Submit new set of files to the central repository:

   ```
   cd locale
   git add fr
   git commit -m "Initial commit language set of files for French"
   ```
user: Show practical ways to work with GeometryNodeInstanceTransform(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeInstanceTransform(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.GeometryNodeInstanceTransform(*GeometryNode*)
:   Retrieve the full transformation of each instance in the geometry

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

assistant: # MaterialLineArt(bpy_struct)

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

*class* bpy.types.MaterialLineArt(*bpy_struct*)
:   intersection_priority
    :   The intersection line will be included into the object with the higher intersection priority value

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

    mat_occlusion
    :   Faces with this material will behave as if it has set number of layers in occlusion

        Type:
        :   int in [0, 255], default 1

    use_intersection_priority_override
    :   Override object and collection intersection priority value

        Type:
        :   boolean, default False

    use_material_mask
    :   Use material masks to filter out occluded strokes

        Type:
        :   boolean, default False

    use_material_mask_bits
    :   Type:
        :   boolean array of 8 items, default (False, False, False, False, False, False, False, 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: How do I use Make Single User in Blender? Include parameters, examples, warnings and best practices.

assistant: # Make Single User

Makes the selected or all object data-blocks single users, that is, not shared
(linked) between other objects in the blend-file.

Additionally, it can also make single-user copies of its dependencies,
like meshes, curves, materials, animations…

Type
:   These actions work on the selected objects, or on all the objects of the scene.

    All, Selected Objects

Data-blocks
:   Lets you, in addition to the menu predefined selection, choose the type of data-blocks individually.

    Object:
    :   Make single user objects.

    Object Data:
    :   Make single user object data.

    Materials:
    :   Make materials local to each data-block.

    Object Animation:
    :   Make the animation of [Object Properties](../../properties/index.xhtml)
        data local to each object.

    Object Data Animation:
    :   Make object data (mesh, curve etc.) animation data local to each object.
user: Give a detailed overview of Import CSV Node: syntax, arguments, return values, common patterns.

assistant: # Import CSV Node

[image reference removed]

The *Import CSV* node reads data from a CSV (Comma-Separated Values) file and generates a point cloud.
Each row in the file becomes a point, with numeric columns imported as attributes.

Attribute names are taken from the header row (if present), and types are inferred from the first value in each
column:

- Integer values create integer attributes.
- Float values create float attributes.

This node is useful for visualizing external datasets in Geometry Nodes,
such as for scientific visualization or procedural generation based on tabular data.
user: Provide the full official documentation entry for Weight Paint Overlays, preserving all code examples.

assistant: Opacity
:   The opacity of the overlay.

Zero Weights
:   Display unreferenced and zero-weighted areas in black.
    This helps to identify areas with very low weights that have been painted onto.

    None:
    :   Vertices are displayed in the usual way.

    Active:
    :   Vertices are shown in black if they have no weight in the active vertex group.

    All:
    :   Vertices are shown in black if they have no weight in any vertex group.

Show Weight Contours
:   Show contour lines formed by points with the same interpolated weight.

    This visualizes weight variations too small to be seen from colors and can be useful for judging
    the smoothness and consistency of gradients, e.g. when using smoothing tools and brushes.

Show Wire
:   Display mesh edges in white (unlike the *Wireframe* overlay which shows them in black).
user: Provide the full official documentation entry for Render Baking, preserving all code examples.

assistant: # Render Baking

Cycles shaders and lighting can be baked to image textures.
This has a few different purposes, most commonly:

- Baking textures like base color or normal maps for export to game engines.
- Baking ambient occlusion or procedural textures,
  as a base for texture painting or further edits.
- Creating light maps to provide global illumination or speed up rendering in games.
user: Describe TextureNodeOutput(TextureNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # TextureNodeOutput(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.TextureNodeOutput(*TextureNode*)
:   filepath
    :   Type:
        :   string, default “”, (never None)

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Built-in Keymaps: syntax, arguments, return values, common patterns.

assistant: Blender provides two default keymaps:

[Blender](blender_default.xhtml)
:   The default keymap, used throughout this manual.

[Industry Compatible](industry_compatible.xhtml)
:   A keymap that more closely matches the shortcuts of other 3D editing applications.
user: Describe Evaluate Closure from the Blender manual or Python API, including usage steps and snippets.

assistant: # Evaluate Closure

[image reference removed]

The *Evaluate Closure* node executes a connected [Closure Zone](../../../interface/controls/nodes/types/utilities/closure/closure.xhtml).
It acts as the *call site* of the closure, running its internal node graph and returning the resulting values.

Closures enable dynamic and customizable node groups by allowing users to pass procedural logic into another node tree.
When the *Evaluate Closure* node runs, the connected closure is evaluated within the current context, matching its input
and output sockets by name.

Common uses for the *Evaluate Closure* node include:

- Allowing user-defined behaviors inside procedural systems (e.g. custom scattering, placement rules, or shading logic).
- Injecting logic into reusable node groups for advanced effects.
- Providing optional customization inputs for high-level node-based tools.
user: Give a detailed overview of ShaderNodeVertexColor(ShaderNode): syntax, arguments, return values, common patterns.

assistant: # ShaderNodeVertexColor(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.ShaderNodeVertexColor(*ShaderNode*)
:   Retrieve a color attribute, or the default fallback if none is specified

    layer_name
    :   Color Attribute

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

    *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 GPU Rendering, preserving all code examples.

assistant: # GPU Rendering

GPU rendering makes it possible to use your
graphics card for rendering, instead of the CPU. This can speed up rendering
because modern GPUs are designed to do quite a lot of number crunching.
On the other hand, they also have some limitations in rendering complex scenes, due to more limited memory,
and issues with interactivity when using the same graphics card for display and rendering.

To enable GPU rendering:

1. Select either *CUDA*, *OptiX*, *HIP*, *oneAPI*, or *Metal*
   in the [Cycles Render Devices](../../editors/preferences/system.html#editors-preferences-cycles) user preference.
2. Enable the available devices for the chosen backend.
3. Configure each scene to use the *GPU Compute* [Device](render_settings/index.html#bpy-types-cyclesrendersettings-device).
user: Describe Deflection from the Blender manual or Python API, including usage steps and snippets.

assistant: Size Deflect
:   Use the particle size in deflections.

Die on Hit
:   Kill particle when it hits a deflector object.

Collision Collection
:   If set, particles collide with objects from the collection.
user: Show practical ways to work with Introduction in a Blender add-on or script – include code.

assistant: # Introduction

Python is an interpreted, interactive, object-oriented programming language.
It incorporates modules, exceptions, dynamic typing, very high-level dynamic data types, and classes.
Python combines remarkable power with very clear syntax.

Python scripts are a versatile way to extend Blender functionality.
Most areas of Blender can be scripted, including animation, rendering, import and export,
object creation and automating repetitive tasks.

To interact with Blender, scripts can make use of
the tightly integrated API.
user: Give a detailed overview of Lights: syntax, arguments, return values, common patterns.

assistant: Light Tree
:   Use a light tree to more effectively sample lights in the scene, taking into account
    distance and estimated intensity.
    This can significantly reduce noise, at the cost of a somewhat longer render time per sample.

    Certain lighting properties are not accounted for in the light tree. This includes custom
    falloff, ray visibility, and complex shader node setups including textures.
    This can result in an increase in noise in some scenes that make use of these features.

Light Threshold
:   Probabilistically terminates light samples when the light contribution is below the threshold.
    This avoids wasting time on lights that contribute little to the image.
    Zero disables the test.
user: Describe Misc Options from the Blender manual or Python API, including usage steps and snippets.

assistant: `--open-last`
:   Open the most recently opened blend file, instead of the default startup file.

`--app-template` `<template>`
:   Set the application template (matching the directory name), use `default` for none.

`--factory-startup`
:   Skip reading the `startup.blend` in the users home directory.

`--enable-event-simulate`
:   Enable event simulation testing feature `bpy.types.Window.event_simulate`.

`--env-system-datafiles`
:   Set the `BLENDER_SYSTEM_DATAFILES` environment variable.

`--env-system-scripts`
:   Set the `BLENDER_SYSTEM_SCRIPTS` environment variable.

`--env-system-extensions`
:   Set the `BLENDER_SYSTEM_EXTENSIONS` environment variable.

`--env-system-python`
:   Set the `BLENDER_SYSTEM_PYTHON` environment variable.

`-noaudio`
:   Force sound system to None.

`-setaudio`
:   Force sound system to a specific device.
    `None` `Default` `SDL` `OpenAL` `CoreAudio` `JACK` `PulseAudio` `WASAPI`.

`-c`, `--command` `<command>`
:   Run a command which consumes all remaining arguments.
    Use `-c help` to list all other commands.
    Pass `--help` after the command to see its help text.

    This implies `--background` mode.

`-h`, `--help`
:   Print this help text and exit.

`/?`
:   Print this help text and exit (Windows only).

`-r`, `--register`
:   Register blend-file extension for current user, then exit (Windows & Linux only).

`--register-allusers`
:   Register blend-file extension for all users, then exit (Windows & Linux only).

`--unregister`
:   Unregister blend-file extension for current user, then exit (Windows & Linux only).

`--unregister-allusers`
:   Unregister blend-file extension for all users, then exit (Windows & Linux only).

`--qos` `<level>`
:   Set the Quality of Service (QoS) mode for hybrid CPU architectures (Windows only).

    default: Uses the default behavior of the OS.
    high: Always makes use of performance cores.
    eco: Schedules Blender threads exclusively to efficiency cores.

`-v`, `--version`
:   Print Blender version and exit.

`--`
:   End option processing, following arguments passed unchanged. Access via Python’s `sys.argv`.
user: Describe Instance Bounds Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Instance Bounds Node

[image reference removed]

The *Instance Bounds* node outputs the axis-aligned bounding box of each instance in the input geometry.
This can be used to determine the spatial extent of instances,
for example, to position or scale objects based on their size.
user: Show practical ways to work with ShaderNodeBrightContrast(ShaderNode) in a Blender add-on or script – include code.

assistant: # ShaderNodeBrightContrast(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.ShaderNodeBrightContrast(*ShaderNode*)
:   Control the brightness and contrast of the input color

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Resample Curve Node

[image reference removed]

The Resample Curve node creates a poly spline for each input spline.
In the *Count* and *Length* modes, the control points of the new poly
splines will have uniform spacing.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Vector
:   Vector of the input system that is to be divided into radial segments.

Sides
:   Number of radial segments to divide the input coordinate system into.
    A non-integer value results in an irregular segment that is smaller than the regular segments.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_0.png   Sides: 5.0. | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_25.png   Sides: 5.25. | ../../../../_images/render_shader-nodes_radial_tiling_segments-5_5.png   Sides: 5.5. | ../../../../_images/render_shader-nodes_radial_tiling_segments-6_0.png   Sides: 6.0. |

Roundness
:   Roundness of the segment coordinate systems.

    |  |  |  |  |
    | --- | --- | --- | --- |
    | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_0.png   Roundness: 0.0. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_25.png   Roundness: 0.25. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-0_5.png   Roundness: 0.5. | ../../../../_images/render_shader-nodes_radial_tiling_roundness-1_0.png   Roundness: 1.0. |
user: Provide the full official documentation entry for Display, preserving all code examples.

assistant: Fade
:   Opacity of the ghosts frames decrease the further away from the current frame.

Show Start Frame
:   Help working on loop animations showing the first keyframe/frame
    as ghost when you are on the last frame of your animation.

[image reference removed]

An example of Onion Skinning activated.
user: Provide the full official documentation entry for Options, preserving all code examples.

assistant: [image reference removed]

Track To constraint.

[Target](../interface/common.html#rigging-constraints-interface-common-target)
:   The object or bone to point towards.

Track Axis
:   The local axis of the owner that should point at the target.
    For bones, this should typically be Y.

    A negative axis will make the owner point away from the target instead.

Up
:   The local axis of the owner that should point upwards in the world.

Target Z
:   Align the owner’s *Up* axis as closely as possible to the target’s Z axis
    instead of the global one.

[Target/Owner](../interface/common.html#rigging-constraints-interface-common-space)
:   The spaces for evaluating the target and owner transforms.

[Influence](../interface/common.html#bpy-types-constraint-influence)
:   How strongly the constraint affects the owner.
user: What is Usage and how is it used in Blender Python scripting?

assistant: ### Running Scripts

The most notable keystroke is `Alt`-`P` which executes the current text as a Python script.
You can access not just the standard Python modules, but also a whole bunch of Blender-specific ones;
see [Scripting & Extending Blender](../advanced/scripting/index.xhtml).
user: What is Relations Management and how is it used in Blender Python scripting?

assistant: [image reference removed]

Linking objects to a collection.

Objects and collections can be reorganized, linked, or parented directly in the *Outliner* using drag-and-drop
operations. This provides an intuitive way to manage scene hierarchies and relationships.

### Moving and Linking

- **Move:**
  Drag an object or collection onto another collection to move it there.
- **Link:**
  Drag an object (or collection) while holding `Ctrl` and drop it onto a collection
  to link it instead of moving it.
  This allows the same object or collection to be part of multiple parent collections at once.

### Parenting

- **Parent to Object:**
  Drag an object onto another object to make it a child of that object.
  Hold `Alt` while dropping to *not* keep the transform relationship (i.e. the child retains its world position).
- **Clear Parent:**
  Drag the child object out of its parent hierarchy to remove the parent relationship.
  Hold `Alt` while dropping to clear the parent while preserving the parent’s transform on the child.
- **Parent Across Collections:**
  To parent an object that resides in a different collection, hold `Shift` while dragging.

See [Parenting Objects](../../scene_layout/object/editing/parent.xhtml#bpy-types-object-parent) for more information on parenting and transformation inheritance.
user: Give a detailed overview of Motion Blur: syntax, arguments, return values, common patterns.

assistant: Each object has its own motion blur settings along with
the [Scene Level Motion Blur](../render_settings/motion_blur.xhtml).
These settings can be found in the Object Properties tab of the Properties.

Steps
:   Controls accuracy of deformation motion blur, more steps uses more memory.
    The actual number of time steps is \(2^{steps -1}\).

Deformation
:   Enables motion blur for deformed meshes such as animated characters, including hair.
user: What is AddStrip(EffectStrip) and how is it used in Blender Python scripting?

assistant: # AddStrip(EffectStrip)

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

*class* bpy.types.AddStrip(*EffectStrip*)
:   Add Strip

    input_1
    :   First input for the effect strip

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

    input_2
    :   Second input for the effect strip

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

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: # Measure

The *Measure* tool is an interactive tool where you can drag lines in the scene to measure distances or angles.
Snapping to geometry could be activated for better accuracy or to measure wall thickness.
The *Measure* tool can be accessed from the Toolbar.

[image reference removed]

Examples of the Measure tool.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Curve
:   Standard geometry input.

Selection
:   Whether or not to change the resolution value on each spline. True values mean the value will be changed,
    false values mean the resolution will remain the same.

Resolution
:   The number of evaluated points generated for each control point in NURBS and Bézier splines.
    It controls the accuracy of operations like trimming or sampling a curve.
    Higher resolutions are more accurate, but slower.
user: Provide the full official documentation entry for Blend-Files Previews, preserving all code examples.

assistant: # Blend-Files Previews

A blend-file can store previews, both for itself, and for some of its [data-blocks](../data_blocks.xhtml).
You can disable writing any previews when saving a blend-file using the *Save Preview Images* setting
from the [Save & Load](../../editors/preferences/save_load.xhtml#prefs-save-load) section of the Preferences.
user: Explain Edge Slide in complete detail according to the official Blender documentation.

assistant: # Edge Slide

Slides one or more edges across adjacent faces with a few restrictions involving the selection
of edges (i.e. the selection *must* define a valid loop, see below).

Even `E`
:   Forces the edge loop to match the shape of the adjacent edge loop.
    You can flip to the opposite vertex using `F`.

Flipped `F`
:   When Even mode is active, this flips between the two adjacent edge loops the active edge loop will match.

Clamp `Alt` or `C`
:   Toggle clamping the slide within the edge extents.

Factor
:   Determines the amount of slide performed.
    Negative values correspond to slides toward one face, while positive ones, refer to the other one.
    It is also displayed in the 3D Viewport footer.

Mirror Editing
:   Lets you propagate the operation to the symmetrical elements of the mesh (if present, in local X direction).

Correct UVs
:   Corrects the corresponding UV coordinates, if these exist, to avoid image distortions.
user: Give a detailed overview of Bone Collections: syntax, arguments, return values, common patterns.

assistant: # Bone Collections

[image reference removed]

The Bone Collections panel in the Armature properties.

This panel contains a Tree View to manage [Bone Collection](../bones/bone_collections.xhtml)
From this panel, Bone Collections can be created, deleted, re-arranged, and more.

Collections can be renamed by double clicking on the name, or right clinking and selecting *Rename*.
To nest a collection inside an existing collection, click and drag the name onto another collection’s name.
Child collection can also be made by `RMB` and selecting “Add Child Collection”.

To the right of the name gives a few controls of the collection:

Visible (Eye)
:   Bones in this collection will be visible in the 3D Viewport.

Solo (Star)
:   Show only this bone collection, and others also marked as “solo”.

Further more, collection that are not empty will have a dot to indicate the collection has bones assigned to it.
user: Describe References from the Blender manual or Python API, including usage steps and snippets.

assistant: |  |  |
| --- | --- |
| - [`AssetShelf.get_active_asset`](bpy.types.AssetShelf.html#bpy.types.AssetShelf.get_active_asset "bpy.types.AssetShelf.get_active_asset") - [`Paint.brush_asset_reference`](bpy.types.Paint.html#bpy.types.Paint.brush_asset_reference "bpy.types.Paint.brush_asset_reference") | - [`Paint.eraser_brush_asset_reference`](bpy.types.Paint.html#bpy.types.Paint.eraser_brush_asset_reference "bpy.types.Paint.eraser_brush_asset_reference") |
user: Explain Views Format Multilayer Items in complete detail according to the official Blender documentation.

assistant: # Views Format Multilayer Items

INDIVIDUAL:
:   Individual.

    Individual files for each view with the prefix as defined by the scene views.

MULTIVIEW:
:   Multi-View.

    Single file with all the views.
user: How do I use General Tools in Blender? Include parameters, examples, warnings and best practices.

assistant: [image reference removed]

General transform and annotate tools like in other modes.

[Move](tools/transforms.html)
:   Translation tool.

[Rotate](tools/transforms.html)
:   Rotation tool.

[Scale](tools/transforms.html)
:   Scale tool.

[Transform](tools/transforms.html)
:   Adjust the objects translation, rotations and scale.

[Annotate](../../interface/annotate_tool.html#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../interface/annotate_tool.html#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../interface/annotate_tool.html#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../interface/annotate_tool.html#tool-annotate-eraser)
    :   Erase previous drawn annotations.